This is Real Life Sale
 
 

Special Offers see all

Enter to WIN a $100 Credit

Subscribe to PowellsBooks.news
for a chance to win.
Privacy Policy

Visit our stores


    Recently Viewed clear list


    Original Essays | March 10, 2015

    J. C. Hallman: IMG One in the Oven; or, Why You Should Suck It Up and Meet Your Favorite Author



    At first, I was dead set against it. I would not try to meet Nicholson Baker while I was writing a book about Nicholson Baker. I had a good reason... Continue »
    1. $18.20 Sale Hardcover add to wish list

    spacer
Qualifying orders ship free.
$27.00
Used Trade Paper
Ships in 1 to 3 days
Add to Wishlist
Qty Store Section
1 Burnside Computer Languages- Perl

More copies of this ISBN

Programming Perl, 3rd Edition

by and and

Programming Perl, 3rd Edition Cover

 

 

Excerpt

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

#LINK<Symbols[ Top ]>#
Symbols
& (ampersand)
   & (bitwise and) operator, 101
   && (logical and) operator, 27, 102, 314
   &&<eq> (assignment) operator, 107
   &<eq> (assignment) operator, 107
   Perl version 5, changes in use, 16
   address-of operator (in C), 110
   in filenames, 752
   prototype character, 227
   for subroutine names, 53-54, 96, 127, 218
      omitting in prototypes, 226
   in variable names, 292
x (asterisk), 96
   dereference operator (in C), 110
   xx (exponentiation) operator, 92
   xx<eq> (exponentiation assignment) operator, 107
   metacharacter, 141, 158
   x<eq> (multiplication assignment) operator, 107
   x (multiplicative) operator, 89, 94
   prototype character, 227
   quantifier, 38, 159, 176
   typeglob, 6, 54, 78
@ (at sign)
   @+ array of ending positions, 667
   @- array of starting positions, 667
   @_ array, 184, 219, 659
   for array names, 6, 53
   changes in use, Perl versions, 591
   in debugger, 508
   in picture lines, 235
   prototype character, 227
   inside strings, escaping with backslash, 62
\ (backslash)
   \... metasymbol, 159
   \\ (backslash)
      double quotes, interpreting with, 7
   to escape metacharacters, 140, 158
   interpretation by regex parser, 191
   metacharacter, 141
   for multiline commands, 507
   \Q notation for backslashing nonalphanumeric characters, 61
   quoted strings, avoiding overuse in, 63
   quotemeta function for, 768
   reference operator, 93, 245
` (backtick), 62, 427 (see also qx//)
   operator, 72, 80, 605
   security and, 567
   shell programming, Perl vs., 590
! (bang)
   complemented character sets, using for, 174
   in debugger commands, 515
   !! debugger command, 515
   ! (logical negation) operator, 92
      overloading, 352
   != (not equal to) operator, 28, 101, 586
   !~ (not binding) operator, 93, 144-145
{} (braces), 264, 586, 603
   { metacharacter, 141, 158
   bare blocks, creating with, 123
   hash composer, 246
   identifiers in, 62
   precedence of, 89
   quantifier, 159
   search patterns, clarifying with use, 65
   for statement blocks, 31, 113
[] (brackets)
   [ metacharacter, 141, 158
   array composer, 245
   to match characters, 201
   character classes, 159, 162, 166
   precedence of, 89
^ (caret)
   bitwise xor operator, 101
   ^<eq> (assignment) operator, 107
   inverting character class, 166
   in matching, 150
   beginning of line assertion, 38, 40, 179
   matching, 201
   metacharacter, 141, 158
   in picture lines, 235
: (colon)
   in ?: (conditional) operator (see ?: operator)
   :: for package identifiers, 65, 291, 591
   :: in module names, translating to system directory separators, 300
   :: in fully qualified names, 55
, (comma)
   delimiting list values, 72, 74
   error in print statements, 586
   key/value pairs and, 10, 76
   large numbers and, 60
   operator, 108
      (see also <eq>> operator )
      scalar context, 592
   as separator, 12
$ (dollar sign), 12
   in debugger, 508
   line boundary, 179
   in matching, 150
   metacharacter, 141, 158
   prototype character, 227
   scalar variable interpolation and, 62
   for scalar variable names, 6, 9, 52, 55
   $#
      prefix for last array index, 76
      obsolete variable for numeric output, 657
   $0 ($PROGRAM_NAME), 672
   $1 et al., 657
   $a and $b (sort variables), 658
   $^A ($ACCUMULATOR), 240, 658
   $_ ($ARG) variable, 36, 39, 658
      angle operator and, 80
      foreach statement and, 118
      glob function with, 84
      grep function and, 730
      map function and, 740
   $^C ($COMPILING), 660
   $? ($CHILD_ERROR), 55, 659
      backtick operator and, 80
      close function and, 693
   $^D ($DEBUGGING), 493, 660
   $^E ($EXTENDED_OS_ERROR), 663
   $) ($EFFECTIVE_GROUP_ID), 660, 672
   $> ($EFFECTIVE_USER_ID), 661
   $! ($ERRNO, $OS_ERROR), 27, 626
   $@ ($EVAL_ERROR), 661
   $^F ($SYSTEM_FD_MAX), 675
   $: ($FORMAT_LINE_BREAK_CHARACTERS), 236, 663
   $- ($FORMAT_LINES_LEFT), 237, 240, 663
   $<eq> ($FORMAT_LINES_PER_PAGE), 237, 663
   $~ ($FORMAT_NAME), 237, 664
   $% ($FORMAT_PAGE_NUMBER), 237, 664
   $^ ($FORMAT_TOP_NAME), 237, 240, 587, 664
      formline function output, 717
   $^H (hints for the Perl parser), 664
   $^I ($INPLACE_EDIT), 665
   $[ (index of first array element), 657
   $. ($INPUT_LINE_NUMBER), 665
      resetting with close function, 693
   $/ ($INPUT_RECORD_SEPARATOR), 492, 666
   $^L ($FORMAT_FORMFEED), 237, 663
   $+ ($LAST_PAREN_MATCH), 668
   $" ($LIST_SEPARATOR), 65, 668
   $^M (memory pool), 668
   $& ($MATCH), 146, 594, 669
   $^O ($OSNAME), 621, 669
   $! ($OS_ERROR), 669
   $| ($OUTPUT_AUTOFLUSH), 237, 670
   $, ($OUTPUT_FIELD_SEPARATOR), 670
   $\ ($OUPUT_RECORD_SEPARATOR), 497, 670
   $^P ($PERLDB), 671
   $] ($PERL_VERSION), 669
   $$ ($PID, $PROCESS_ID), 55
   $' ($POSTMATCH), 146, 184, 594, 671
   $` ($PREMATCH), 146, 594, 672
   $$ ($PROCESS_ID), 672
   $^R ($LAST_REGEXP_CODE_RESULT), 211-212, 668
   $( ($REAL_GROUP_ID), 672
   $< ($REAL_USER_ID), 672
   $^S ($EXCEPTIONS_BEING_CAUGHT), 662
   $; ($SUBSCRIPT_SEPARATOR), 78, 674
   $^T ($BASETIME), 100, 659
   $^V ($PERL_VERSION), 671
   $^W ($WARNING), 137, 675
   ${^WARNING_BITS}, 676
   ${^WIDE_SYSTEM_CALLS}, 404, 676
   $^X ($EXECUTABLE_NAME), 662
. (dot), 96
   .. (range operator), 103
   ... (range operator), 103
   character wildcard, 37, 147
   (concatenation) operator, 23
      autogeneration via stringification handler, 352
   quantifiers, use in, 38
   separating integers in v-strings, 67
" (double quotes), 60, 143, 264
   (see also qq// and the print function)
   conversion operator, stringification, 351
   in formline arguments, 717
   in replacement string, 152
   translation escape processing, 192
<eq> (equal sign), 77
   <eq> (assignment) operator, 6, 107
   <eq><eq> (equal to) operator, 24, 28, 101, 586
   <eq>> (corresponds to) operator, 108
   <eq>~ (pattern binding) operator, 36, 93
      using with pattern matching operators, 144
   <eq><eq>> current line marker, 508
   debugger command, 516
- (hyphen), 96, 201
   -<eq> (assignment) operator, 107
   -- (autodecrement) operator, 91
   -x- for emacs, 488
   -- command-line switch, 492
   -> (arrow) operator, 90, 253
      method invocation with, 312
   arithmetic negation operator, 92
   in character ranges, 166
   character set subtraction, 173
   debugger command, 514
   subtractive operator, 95
< (left angle bracket)
   < (less than) operator, 21, 28, 100
   <<eq> (less than or equal) operator, 28, 100
   <=> (comparison) operator, 28, 101, 789
   << for here documents, 66
   << (left-shift) operator, 95
   <<<eq> (assignment) operator, 107
   <> construct (see angle operator)
   in debugger commands, 515
   in filenames, 748
   for filename globbing, 83
   for left justification, 239
   for line input, 80
() (parentheses), 12, 88-89, 605
   (...) grouping, 159
   (?:PATTERN) notation, clustering without capturing, 185
   for backreferences, 41, 182, 184
   conditional operator, use with, 105
   in functions, 677
   grouping operator, 142, 201
   for list values, 72
   metacharacter, 141, 158
   null lists, representing, 73
   as quote characters, 74
% (percent sign), 96
   for checksums, 821
   for hash names, 10, 53
   modulus operator, 94
   %<eq> (modulus assignment) operator, 107
   prototype character, 227
   signifying variable type, 6
+ (plus sign), 96
   additive operator, 95
   ++ (autoincrement) operator, 26, 91
   in filenames, 748
   metacharacter, 141, 158
   +<eq> (plus equals) operator, 107
   + unary operator, 89, 92
   +? quantifier, 159
   in quantifiers, 37, 176
# (pound)
   for comments, 49
      /x pattern modifier, using with, 148
   in formats, 235
   quoting character, whitespace and, 64
   #! (shebang) notation, 19, 487, 1001
      security problems caused by, 569
      simulating on non-Unix systems, 489
? (question mark), 96
   ?: (conditional) operator, 105, 125
   metacharacter, 141, 158
   in quantifiers, 38, 159, 176
   ?? quantifier, 159
   ?? operator (see m?? operator)
? (question mark) regex extensions
   (?=), 202
   (?!), 202
   (?>), 204
   (?<=), 202
   (?<!), 202
> (right angle bracket)
   in debugger commands, 515
   in filenames, 748
   for filename globbing, 83
   greater than operator, 21, 28, 100
   ><eq> (greater than or equal) operator, 100
   >><eq> (right-shift assignment) operator, 107
   line input operator (see angle operator)
   for right justification, 239
   >> (right-shift) operator, 95
=> (equals sign, greater-than sign)
   comma separator, Perl alternative to, 10
; (semicolon), 111
   in debugger commands, 509
   errors, omitting trailing, 586
   in filenames, security risks of, 566
   Perl statements, terminating with, 49
   simple statements, ending in, 111
' (single quotes), 60
   as delimiters, variable interpolation and, 63
/ (slash), 96
   debugger command, 514
   delimiters, replacing as, 63
   division operator, 94
   /<eq> (division assignment) operator, 107
   // (see m// operator)
   root directory, 692
~ (tilde)
   bitwise negation operator, 92
   to suppress blank lines, 236
_ (underscore), 55
   global filehandle, 657
   large numbers and, 657
   Perl versions, changes in use, 591
   in variable names, 605
| (vertical bar)
   ...|... alternation, 142, 159, 187
   bitwise or operator, 101
   |<eq> (bitwise or assignment) operator, 107
   centering with, 238
   || debugger command, 516
   in filenames, 748
   || (logical or) operator, 102, 189, 314
      precedence, chdir vs., 89
   ||<eq> (logical or assignment) operator, 107
   metacharacter, 141, 158
   -| piping pseudocommand, 429
   |- piping pseudocommand, 428
Numbers
0+ (numification) operator, 351
0 but true, 713
   -w exemption, 712
-0 command-line switch, 487, 492
32-bit systems, 623
64-bit systems, 623

#LINK<A[ Top ]>#
-A (access age) file test operator, 100
\A (string boundary), 179
-a (autosplit) command-line switch, 492, 663
abbreviations, text, 866
abs (absolute value) function, 683
abstraction, 288
   in object-oriented programming, 311
accept function, 683
access checks, setting in constructor, 341
access time, file, 801, 824
accessing
   array of hashes, 279
   elements, tied arrays, 374
   hashes of arrays, 276
   multidimensional arrays, 271
   multidimensional hashes, 281
   overridden methods, 324
   records of elaborate data structures, 283
   slices of multidimensional arrays, 272
accessor methods, 319, 979
   class data methods, working like, 344
   creating, 332
   generating with autoloading, 337
   generating with closures, 338
   pseudohashes and, 334
$ACCUMULATOR, 658
actions (debugger)
   command execution, specifying from debugger, 514
   listing all, 512
ActiveState Perl distribution
   Microsoft-only modules, 875
   PPM (Perl Package Manager), 552
ActiveState Perl distribution, installing on Windows systems, 490
adding additional array elements, 821
addition, 23
   overloaded plus (+) operator, 349
additive operators, 95
addresses
   C language, Perl vs., 589
   getting from hostnames, 722
   network, getting from hostnames, 721
   network, translating to names, 720, 722
   packed socket, 727
   reused, displaying contents of, 521
   socket names as, 684
address-of operator (in C), 110, 979
.al filename extensions, 297
alarm function, 683
   pattern match, timing out, 584
alert (bell), 61
algorithms, 979
   Perl modules for, 549
aliases, 979
   for characters, 163
   debugger command for, 516
   for/foreach loops, creating with, 125
   symbol table entries, 56, 79
   symbol table key, assignment to typeglob, 294
aliasing
   for/foreach loops, 118
      searching and replacing elements in arrays, 154
ALRM signal, 417
alternation, 142, 979
   character classes and, 166
   interior, limiting scope of, 185
   match one or the other (...|...), 159
   in patterns, 187
   precedence, pattern matching, 198
anchors, 40, 178
and (&&) logical operator, 27, 102-103, 109, 606
   precedence, and operator vs. &&, 314
and (&) bitwise operator, 101
angle operator, 80, 386, 495, 588
anonymous, 979
   array composer, 245
   arrays
      hash of, creating, 275
      two-dimensional array slice, 272
   hash composer, 246
   hashes
      adding to multidimensional hashes, 280
      array of, creating, 277
      data structue for objects, 317
   pipes, 426-428
   referents, 244
   subroutine composer, 247
   subroutines, 217
      giving names at run time, 295
AnyDBM_File module, 870
Apache web server, 539
   CGI::Apache module, 870
   mod_perl extension, 475
   Perl modules for, 550
appending
   elements to arrays, 270, 767
   members to existing hash, 278
arctangent (see atan2)
$ARG (English for $_), 658
argument, 980
   (see also parameters)
@ARGV array, 82, 659
ARGV filehandle, 659, 980
$ARGV variable, 659, 980
ARGVOUT filehandle, 659
arithmetic operators, 92, 980
   binary arithmetic operators, 23
   order of evaluation, 23
   overloading, 349, 352
arity, 86
   highest to lowest, listing of, 87
arrays, 5, 8, 51, 65, 980
   (see also lists)
   @_ arrays, 219
      copying values to my list, 220
   anonymous, objects implemented as, 333
      use fields pragma, overcoming problems with, 334
   anonymous, references to, 245
   appending elements to, 767
   associative (see hashes)
   AV (array value) typedef in C, corresponding to, 531
   context (see list context)
   deleting elements of, 785, 793
   elements, giving temporary values to, 738
   exists function and, 710
   first element of, 657
   of hashes, 277-279
      accessing and printing, 279
      generating, 278
   hashes of, 275-277
   initializing with x operator, 94
   last element of, 76
   length of, 76
   list values vs., 73
   lists and, 72-76
   multidimensional, 13, 268
   names for, 53
   negative subscripts, counting from end of array, 592
   nested, 268-275
      two-dimensional arrays, creating and accessing, 269
   output style, changing in debugger, 521
   parsing text into, 866
   passing by reference into or out of functions, 224
   performance and, 598
   pop function and, 764
   prepending elements to, 821
   processing, functions for, 680
   references to, 244
   replacing/removing elements, 793
   subscript separator (see $; variable)
   s/// (substitution) operator and, 154
   tainted, 559
   tied
      delete function and, 593
   tying, 372-378
      methods for, 373-377
      notational convenience, 377
      Tie::Array module, 871
   variables of, 65
arrow (->) operator, 90, 253, 312
artificial languages, 4
ASCII, 48, 980
   converting to characters, 692
   converting to Unicode, 406
   values for characters, 755
ASP, Perl modules for
assertions (in patterns), 141, 159, 980
   character classes and, 166
   defining your own, 215
   lookaround assertions, 202
   positional, 178-182
      \A and ^ assertions (string boundary), 179
      \G positional assertion, 151
      \z, \Z, and $ assertions, 179
      \b and \B (word and nonword boundary), 180
   precedence, pattern matching, 199
assigning to lists, 75
assignment, 980
   to ?: (conditional) operator, 106
   elements, two-dimensional arrays, 270
   of tied variables, 369
   tied array element, 374
assignment operators, 24-25, 51, 980
   overloading, 353, 357
      (see also copy constructor)
   precedence
      Perl versions, differences in, 592
   values, returning, 25
assignment operators, 107
associative arrays (see hashes)
associativity of operators, 86, 100, 980
x (see asterisk, under Symbols)
astronomy
   Perl modules for, 551
async function (in Thread module), 450
atan2 (arctangent) function, 684
$atime file statistic, 801
atoms, 199, 980
   precedence, pattern matching, 201
attributes, 980
   attributes pragma, 871
   class, 745
      storing state for, 343
   files, test operators for, 28
   locked and method, using with threads, 342
   locked, subroutines, 458
   lvalue, subroutines, 342
   in object-oriented programming, 319
   objects, hashes of, 13
   subclass, overriding superclass ancestor, 333
   subroutines, 231-233
      names, syntax for, 231
   variable interpolation and, 756
attrs module (obsolete), 871
audio
   Perl modules for, 551
authentication
   modules for, 550, 870
authorization
   Perl modules for, 550
autodecrement (--) operator, 26, 91
   magical, 353
autoflushing buffers, 670
autogeneration, overloading, 352, 980
   autoincrement and autodecrement, 353
   preventing, 358
autoincrement (++) operator, 26, 91, 354, 980
AUTOLOAD subroutine, 127, 296-298, 328
AutoLoader module, 297, 873
autoloading, 981
   generating accessors with, 337
   methods, 328
automatic
   line-end processing, 497
autosplit mode (with -a switch), 492, 981
AutoSplit module, 297, 873
   portability of, 625
autouse pragma, 873
autovivification, 90, 710, 981
   of filehandles, 431, 748
   typeglobs, 385
AV (internal array value), 531, 981
awk, 35, 981
   converting to/from Perl, 78

#LINK<B[ Top ]>#
-b (block special) file test, 98
-B (binary) file test, 98
\B (nonword boundary) assertion, 180
\b (word boundary) assertion, 40, 141, 180
   for backspace, 166, 201
B module, 874
B::Asmdata module, 874
B::Assemble module, 874
B::Bblock module, 874
B::Bytecode module, 477, 874
B::C and B::CC modules, 478
B::C module, 874
B::CC module, 874
B::Debug module, 874
B::Deparse module, 480, 874
B::Disassembler module, 874
B::Lint module, 479, 874
B::Showlex module, 874
B::Stash module, 874
B::Terse module, 874
B::Xref module, 479, 874
backends, compiler, 476, 874
   generic interface to, 874
   modules, 476
   modules, calling, 476
backquotes (`), 7
backreferences, 41, 150, 182, 587, 657, 981
   (see also patterns, backreference)
   accessing with numbered variables, 183
   creating with parentheses, 184
   deriving patterns from matched substrings, 213
backslash (\)
   interpreting with double quotes, 7
backspace, 61
   \b assertion in character classes, 166, 180, 201
backticks, portability of
backtracking, 197, 981
   nonbacktracking subpatterns, 204
   in pattern matching, 197
backup files, 496
bar (see vertical bar under Symbols)
bare blocks, 123-126
   case structures, doing with, 124
bare identifiers, 65
barewords, 64, 981
   avoiding, reasons for, 588
   Perl versions, changes in, 591
   strict pragma, checking use of, 138
base classes, 309, 871, 981
   constructors and, 321
   overridden methods, invoking all, 327
   overriding methods of, 324
   for pod filters and translators, 872
   UNIVERSAL module, providing for all classes, 871
base module, 871
basename, files, 867
$BASETIME, 659
basetime ($^T), 659
BASIC programming language
   logical operators borrowed from, 26
BEGIN blocks, 465, 531
   altering compiler parsing of file, 482
   initializing variables before calling subroutines, 223
   modifications to @INC array, handling with, 300
   order of running, 481
beginnings of strings, matching, 179
Benchmark module, 874
   comparing running times of alternate code versions, 875-877
bidirectional communication, pipes, 430-432
bidirectional rendering, Unicode properties, 171
big-endian, 623, 981
/bin/sh, 488
binary, 981
   mode on filehandles, 685
   operators (see binary operators)
   pack function, 757-762
binary files, 753
   decompiling with B::Deparse module, 480
   as regular files, 29
binary operators, 22, 36, 86-110, 981
   overloading, 348
bind function, 684, 981
binding
   DBM file to hash, 696
   operators (=~, !~), 36, 93, 144
   variables to packages, 363, 813, 821
binmode function, 685, 753
biology
   Perl modules for, 551
bit, 981
bit vector, providing array interface to, 398
bitmasks, 781
bit-shift operators (<<, >>), 95, 107, 981
bitwise
   negation (~) operator, 92
   operators, 101, 109
      overloading, 353
blank lines, truth value of, 32
bless function, 248, 258, 317, 686, 982
   constructors, using with, 317
   reference as argument for, 244
   tie vs., 364
blib pragma, 536, 873
$blksize file statistic, 801
block properties, Unicode, 171
blocking calls
   lock, threads, 455
blocking, shared locks, 420
blocking signals, 418
blocks, 30, 50, 111, 113, 121, 252, 982
   bare, 123-126
   continue block, 115
   loops and, 735
   package declarations, span of, 290
   (see also statements)
$blocks file statistic, 801
Boolean, 982
   context, 70, 982
      bool conversion operator, 351
      m// (match) operator in, 150
   definition of truth, 29
   operators, 29
   values, 7
bootstrapping modules, 535, 873
boundaries, words (matching), 180
boundary assertions, 40
bounded array, creating, 373
{} (braces)
   quantifiers, 38
   hash key, enclosing in, 12
brackets []
   array subscripts, enclosing in, 9
   lists, converting to scalars, 12
break command (in C), 589
break statement (see the last operator)
breakpoints, 982
   deleting, 511
   listing all, 512
   setting for debugger, 506
   setting on load, 509
   setting with debugger commands, 511
   watch expressions, causing, 512
broadcast, 982
BSD, 982
BSD::Resource module
   per-process resource limits, setting, 584
buckets, 982
buffering, 982
   bi-directional pipes, problems with, 431
   block, 982
   single-character input and, 718
   unflushed buffers in Perl versions, 715
bug reports, xxxi
bugs, 917
building CPAN modules, 552
built-in, 982
   data types, 50-52
   functions
      character semantics, operating on, 405
      listing by type, 872
      overriding, 306
      subroutines, prototyping to emulate, 226
   methods
      overridden, calling via CORE pseudopackage, 324
bundles, 549, 982
byte meanings, character class shortcuts, 167
bytecode, 466, 530, 982
ByteLoader module, 477, 874
bytes, 47, 982
   bit-shift operators, 95
   characters vs., 402, 680
   reading, 769, 810
bytes module, 868

#LINK<C[ Top ]>#
-c (character special) file test, 98
-c (check syntax) command-line switch, 493, 531, 660
-C (inode change time) file test, 100
-C (native wide characters) command-line switch, 404
\C (matching single byte in C language) wildcard metasymbol, 164, 406
/c modifier, 156
   failed matches, searching past, 181
C language, 983
   accessing Perl from enclosing framework, 476
   C code generators, 478
   C stack, storing C variables on, 474
   C-style logical operators, 102
   fcntl.h definitions, loading as Perl constants, 869
   library functions, 678
   library, signals triggering core dumps in, 413
   operators missing in Perl, 110
   operators, precedence relationships, 88
   Perl, extending with, 530, 532-538
      creating extensions, 534-537
      external C library, using functions from, 538
      XSUBs and XS language, 533
   Perl functions, wrapping around, 533
   Perl, running from
      Perl stack, manipulating, 542
   Perl, using from, 538-544
      adding Perl interpreter, 539
      compiling embedded Perl programs, 539
      Perl statement, evaluating, 541
      Perl subroutine, calling from, 540
      XSUB input and output, 537
   preprocessor, 983
   programming, differences from Perl, 589
   structs, 761
   syslog functions, using in Perl, 869
   wrapper programs, 570
C preprocessor, 499
caching, 267, 323, 381, 397, 422, 434, 550, 609
callbacks, 260, 983
caller function, 687
   Perl versions, changes in return value, 592
calling
   by reference, 219, 224, 983
   subroutines indirectly, 218
   by value, 220, 983
can method (in package UNIVERSAL), 326
canonical decomposition, characters, 170
canonicalization, 983
   characters, information on, 406
capitalization, 54, 817
   barewords, problems with, 64
   changing, 157
   escape sequences for, 61
   label names, 115
   lc and lcfirst functions, 736
   method names, tied variables, 365
   in module names, 866
   module names, 300
   package/module names, 605
   subroutine names, 218
   uppercase, converting to (\u escape), 152
capturing in patterns, 182-185, 983
   suppressing in clustering, 185
   words, alphanumeric, 151
^ (see caret, under Symbols)
Carp module, 367, 872, 878
carriage returns, 622
   (see also newlines)
case
   case-sensitive matching, switching off, 147, 157, 193
   escape sequences for
      processing during variable interpolation pass, 162
   matching, /i operator, 147
   translation operators, using Unicode tables, 407
case structure, 124
casting, strings and
cat command (Unix), 381
categories
   of characters, 169
   of functions, 680-681
cbreak option, 718
C/C++ languages, static variables
centering, 238
/cg pattern modifier, 150
CGI
   Perl modules for, 550, 870
   managing HTML forms with CGI.pm, 878
CGI scripts
   input, evaluating (Safe module), 579
   taint mode, necessity of running under, 559
CGI::Apache module, 870
CGI::Carp module, 870, 879
CGI::Cookie module, 870
CGI::Fast module, 870
CGI::Pretty module, 870
CGI::Push module, 870
character classes, 37, 165-176, 201, 983
   confusing with array subscripts, 65
   custom, 166
   matching against character properties in Unicode, 407
   metasymbols used within, 162
   Perl classic, 174
   Perl shortcuts for, 167
   POSIX-style, 174-176
   predefined, availability of, 407
   Unicode properties, 167-174
   wildcard metasymbols and, 164
character semantics
   effects of, 405
character sets
   ordering and ranges of characters in, 156
   portability of, 628
   Unicode, 401-410
characters, 47, 201, 983
   (see also patterns and character classes)
   $[ variable, 657
   aliases for, 163
   bytes vs., 402, 680
   converting between fixed 8-bit and variable-length UTF-8, 403
   decomposition of, 170
   deleting, 689
   in formats, 758
   getting ASCII values of, 755
   getting from ASCII values, 692
   getting from Unicode values, 692
   hexadecimal (see hexadecimal characters)
   length in, 736
   metacharacters, 140
   metasymbols, 166
   octal (see octal characters)
   in patterns, 140-142
   properties, 173
      defining your own, 173
      (see also Unicode)
   prototype, 227
   replacing in strings, 156
   single-character input, 718
   wildcard matches for, 164
   special, 201
charnames pragma, 868
charts, generating, 234
chdir command
   calling without argument, 503
chdir function, 688
   precedence and, 89
CHECK blocks, 465, 531
   order of running, 481
checking
   taint, 559
checksums, 821
chemistry
   Perl modules for, 551
$CHILD_ERROR, 659
child processes, 826
   ID, returning, 715
   starting readable, 427
   starting writable, 426
   (see also processes)
chmod function, 19, 688
chomp function, 22, 689
chop function, 22, 690
   (see also chomp function)
chown function, 691
chr function, 408, 692
chroot function, 692
chroot syscall, 577
circular references, 266
   breaking, 331
   overloading, avoiding in, 356
circumfix operator, 983
class methods, 308, 983
   constructors as, 318
   package names as invocants for, 311
   Thread class, 450
Class::Contract module, 341
Class::Multimethods module, 325
Class::Struct module, 866, 879
classes, 289, 308, 983
   base (see base classes)
   data, managing for, 343-346
      storing references to class data in object itself, 345
   definitions of
      object-oriented modules as, 299
   functions dealing with, 681
   generating with Class::Struct module, 336
   implementing tie, 364
   implementing tied filehandles, 384
   implementing tied hashes, 378
   inheritance among, 321-330
      base module, 871
      method autoloading, 328
      overridden methods, accessing, 324
      private methods, avoiding with, 329
      UNIVERSAL class and, 326-328
   @ISA array, including with base pragma, 323
   modules vs., 289
   objects, giving to, 317
   package, 90, 813, 821
   packages as, 310
   pseudohash implementations of, 744
   quoting packages for, 316
   scalar-tying, 366-370
   version number, returning, 327
classes, Perl, 165
clearing hashes, 382
clients, networking, 983
   getting name of, 442
clients, TCP, 439
cloisters, 186, 983
close function, 428, 693
closedir function, 694
close-on-exec flag, 675
closing server connections (half-close), 440
closing tied filehandles, 387
closures, 132, 259-263, 983
   assigning to glob to define subroutine, 297
   creating, 217
   as function templates, 261
   generating accessor methods with, 338
   nested subroutines, emulating with, 262
   private objects, using for, 339-342
   threads, 450
clustering in patterns, 185, 983
   without capturing, reasons for, 185
cmp operator, 28, 789
code
   efficiency of, 600
   extracting and displaying with debugger, 513
   insecure, handling, 576-584
      code masquerading as data, 581-584
      safe compartments for, 577-581
      safe examples, 579
   mixing character semantics with byte semantics, 404
   reusing, 607
code generation, 466, 874
code generators, 476-478, 984
   bytecode generator, 477
   C code generators, 478
code subpatterns in regular expressions, 210
coderef (see subroutine references)
collating sequence, 984
combining character sequence
   \X, matching with, 407
combining character sequence, matching with \X, 165
comma (,) (see comma under Symbols)
command input operator (see backtick)
command interpreters, 486
   quoting on Unix systems, 490
command line
   calling Perl interpreter from, 18
   Perl modules for editing, 550
   modules for processing, 867
   screen appearance of, 520
command processing, 486-502
   location of Perl, 491
command-line flags and switches (see option processing)
commands
   accessing under reduced privileges, 566-568
   buffering, 670, 984
   debugger, 509-518
      actions and, 514
      breakpoints, 511
      documentation, viewing, 517
      for display::display, 512
      locating code, 513
      options, manipulating, 517
      quitting debugger, 516
      restarting debugger, 516
      stepping and running, 510
      tracing, 512
   hashes of functions, storing in, 282
   history, debugger and, 507
   for loop control, 120
   names for, 16
   in pod, 632
   processing, 486
   recalling, debugger option, 519
comments
   definition, 49, 984
   discarding before processing, 189
   extending with /x pattern modifier, 148
   multiline, 630
   Perl vs. C syntax for, 589
comparing
   files, 867
   running time of alternate code versions, 874
   strings, 100, 586
   thread objects, 453
comparison operators, 27-28, 101
   overloading, 354
   sort function and, 789
compatibility decomposition, characters, 170
compilation, 530
   order of, 484
compilation phase
   processing Perl program, 531
compilation unit, 56, 984
compile phase vs. compile time, 467, 984
compiler, Perl, 660
   backends for, 476
   hints for, 664
   modules related to, 549
compilers, 984
   global declarations and, 127
   regex compiler, 195
compilers, Perl
   interpreters, interaction with, 480-485
   modules related to, 874
compile-time
   controlling debugger during, 509
compiling, 464-485
   compiling your code, 467-473
   embedded Perl program (in C), 539
   life cycle of Perl programs, 465
   life cycle, Perl programs
      code generation phase, 466
      compile phase, 465
      parse tree reconstruction, 466
comp.lang.perl newsgroups, xxxi
complement (see negation)
complex data structures
   creating in Perl, 268
   representing as scalars, 13
composite Unicode properties, 168
Comprehensive Perl Archive Network (see CPAN)
COMSPEC environment variable, 504
concatenation (.) operator, 23, 95, 598, 984
   autogeneration via stringification handler, 352
   string constants, overloading, 360
condition variables, 459
conditional (?:) operator, 105, 125
conditional code execution, 27
conditional context (see Boolean context)
conditional statements, 114
   without braces, writing, 113
   (see also if statements; unless statements)
conditionals
   interpolation into patterns, 214
conditions, expressions in loops, 116
%Config hash, 539, 622
Config module, 873
   operating system mapping between signal names and numbers, 414
configuration
   Perl, for debugging, 494
configuration files
   Perl modules for, 550
connect function, 694
connection, shutting down, 787
constant pragma, 295
constants, 295
   inlining constant functions, 228
   overloading, 359
   Perl, loading fcntl.h definitions as, 869
   System V IPC, defining for, 869
constructors, 248, 308, 317-321, 985
   access checks, setting in, 341
   bless function and, 317
   class names or objects, working with, 319
   inheritable, 318
   initializers, 319
   naming, 320
   new method, 745
   tied variable classes, 364
container classes holding pointers to self-referential data structures, 331
context, 69-72, 985
   Boolean context, 70
   interpolative (double-quoted) context, 72
   scalar and list context, 69
   void, 71, 827
   (see also list context; scalar context)
context stack, 474
continuation lines, 121, 663, 985
continue block, 115, 120-121
   (see also loops)
continue command (in C), 589
contract between module and user, 302
contractions in words, avoiding confusion with single quotes, 203
control characters, 60
   metasymbols in patterns, 163
   non-ASCII on Macintosh, 491
control structures, 29-35
   truth, defining, 29
control variables, 118
Control-A, 152
Control-C, 61
   signals, handler for, 413
Control-C or Control-Z, generating signals with, 412
Control-D as end-of-file, 68, 618
Control-Z as end-of-file, 68, 618
conversion operators
   Boolean context, interpreting object in, 351
   numification (nonnumeric variable converted to number), 351
   stringification, 351
converting
   ASCII value to character, 692
   between integers and UTF-8 characters, 408
   between languages, 619
   characters to ASCII values, 755
   data types between C and Perl, 543
   decimal numbers to binary, octal, or hexadecimal, 797
   hexadecimal numbers to decimal, 730
   list values to strings, 733, 757
   numbers to/from hexadecimal, 153
   octal numbers to decimal, 746
   strings to list values, 794, 819
   time, 728, 738
   Unicode value to character, 692
cookies (HTTP), setting and getting, 870
copy constructor, 357
copying filenames or filehandles, 867
copy-on-write semantics, 447
core dumps, 985
   denial-of-service problems with pattern matching, 583
   dump function for, 703
   signals triggering in C library, 413
   Thread::Signal module, preventing with, 462
core files, 501
core modules, Perl, 549
CORE pseudopackage, 306, 324
   CORE::GLOBAL pseudopackage, 306
cos (cosine) function, 694
counters
   magical counter variables, 370
CPAN (Comprehensive Perl Archive Network), 15, 289, 299, 547-556
   CPAN.pm module as automated interface to, 873, 881
      installing modules with, 552
      portability of, 627
   modules
      building, 552
      categories of modules, 549
      creating, 554-556
      decompressing and unpacking, 552
      installing and building, 551
      installing into Perl library, 553
   modules directory, 549-551
   subdirectories, 547
   tie modules on, 397-398
CPU
   access in multitasking environment, 569
   condition variables allowing threads to relinquish, 459
CPU time, 816
CPU, yielding (threads), 454
cracker, 985
creation time (see modification time, file )
credit cards
   Perl modules for, 551
CRLF, 622
   in Internet programs, 443
   (see also newlines)
crypt function, 695
cryptography, 800
$ctime file statistic, 801
curly braces (see braces under Symbols)
current package, 985
Curses
   Perl modules for, 550
customization
   debugger, 518-521
      debugger options, 519-521
      editor support for, 518
      functions for, 525
      init files, using, 518
CV (internal code value), 985
Cwd module, 867
   current working directory for process, determining, 881

#LINK<D[ Top ]>#
-d (directory) file test operator, 28, 98
-d (debug) command-line switch, 493, 525
-D (debugging) command-line switch, 493
/d pattern modifier, 156-157
\d (digit) pattern metacharacter, 37
^D (Control-D) as end-of-file, 618
daemons
   Perl modules for, 551
   taint mode, importance of enabling for, 559
data
   byte-oriented vs. character-oriented, 402
   fixed-length, functions for, 680
   insecure handling, 558-568
      code masquerading as data, 581-584
      command and file access under reduced privileges, 566-568
      detecting and laundering tainted data, 561-564
      environment, cleaning up, 565
   screen dump, providing, 871
data access
   threads, 454-463
      condition variables, 459
      deadlock, 457
      locking methods, 459
      locking subroutines, 457
      synchronizing with lock, 455
      unlocking, 456
DATA filehandle, 660
data organization in Perl, 275
data structures, 268-287, 549, 985
   arrays of hashes, 277-279
   complex, representing as scalars, 13
   flat or linear in Perl, 242
   hashes of arrays, 275-277
   hashes of functions, 282
   multidimensional hashes, 279-282
   for objects, 317
   objects (see objects)
   persistent
      providing via tie, 398
   records of elaborate, 283-286
   references to, 244
   saving, 286
   self-referential, container classes holding pointers to, 331
   stringifying, 286
__DATA__ token, 68, 660
data types, 5, 985
   built-in, 50-52
   converting between C and Perl, 543
   internal, Perl and C, 531
   modules for, 866
   scalars (see scalars)
   TYPE declarations in Perl, 744
   typeglobs, 78
Data::Dumper module, 286, 871, 882
databases
   (see also DBI)
   Perl connections to, 139
   Perl modules for operating, 550
   tying hash variables to, 363
datagrams, 438, 985
date function (see localtime function)
dates
   Perl modules for, 549
dates, portability of, 627
DB_File module, 870
   Data::Dumper module, using with, 882
DB module, 871
   caller function, 688
DBD (Database drivers)
   Perl modules for, 550
DBI (Database Interface)
   Perl modules for, 550
DBM files, 985
   complex data values, storing in, 882
   dbmclose and dbmopen functions, 696
   deleting from, 699
   locking, 422
   modules for, 870
   portability of, 627
   storing complex data values in, 397
dbmclose function, 363
dbmopen function, 363
   use declarations with, 365
dbprofpp program, 526-528
deadlock in threads, 457
deallocating memory, 266
debugging, 493, 506-529, 559
   backend modules for, 476
   bug reports, xxxi
   controlling from programs, 509
   DB module, 871
   debug level, setting through class or instances, 344
   debugger code, command for loading, 504
   debugger customization, 518-521
   debugger support, Perl, 523
   debugger, unattended execution, 521
   Devel::Peek module for XS programs, 871
   global destruction of objects other references, controlling, 505
   overloading, 362
   Perl debugger commands, 509-518
   Perl, using C compiler -DDEBUGGING option, 322
   turning on in tied filehandle, 391
   Unix security bugs, 569
   (see also taint)
$DEBUGGING, 660
debugging flags, 660
decimal points, lining up, 235
declarations, 3, 111-138, 986
   field with use fields pragma, S
   formats, 234
   global, 127
   global variables
      lexically scoped, 133
   methods
      lvalues, indicating return of, 342
   package, 14, 129, 290, 762
   scoped, 129
   structs, 336
   subroutines, 127, 217, 804
      without defining, 217
   use declarations, 15
   variables, 111, 130
declarative approach, regular expression programming, 206
decomposing characters into simpler ones, 170
decompressing CPAN modules, 552
decrementing variables, 26, 986
decryption (see encryption)
default package, 129
DEFAULT pseudosignal, 414
defined function, 697
defining, 986
   subroutines, 219
definitions
   classes
      object-oriented modules as, 299
   subroutines
      loading from other files, 128
      loading with AUTOLOAD, 297
   subroutines, declarations vs., 127
DEL in hexadecimal, 61
delete function, 699
   tied arrays, not returning deleted value for, 593
deleting
   all debugger actions, 515
   array elements, 764, 785, 793
   breakpoints, 511
   characters, 689
   directories, 777, 819
   files, 819
   found but unreplaced characters, 156
   hash elements, 699
delimiters, 986
   pattern-matching operators and, 145
denial-of-service problems, security concerns with, 583
dereference operators, overloading, 356
dereference-address operator (x), C language, 110
dereferencing, 244, 251-253, 986
   array elements, 271
   hash values as functions, 283
   operator for (see arrow operator)
   typeglobs, 293
   (see also references)
derived classes, 309, 986
   methods as wrappers around base class methods, 324
descriptor (see file descriptor)
DESTROY method
   sigtrap pragma and, 414
destroying threads
   detach method, 453
   join method, 451
destruction of objects and other references, controlling, 505
destructors, 330, 986
   garbage collection with, 331
   shared memory and semaphore, 437
detach method (in Thread module), 453
$dev file statistic, 801
Devel::DProf module, 525, 871
   profiling subroutine execution with, 525-529
Devel::Peek module, 871
Devel::SelfStubber module, 873
Devel::SmallProf module, 529
development support, modules for, 549
diagnostic messages (see error messages; warning messages)
diagnostics pragma, 871
die function, 700
   exit function versus, 711
   quit signal handling and, 413
digits, 37
   in names, 55
directives (pod), 632
directories, 986
   changing working, 688
   closing, 694
   creating, 741
   creating or removing portably, 867
   current working, getting pathname of, 867
   deleting, 777, 819
   DirHandle module, 868
   file test checks on trees, 867
   functions dealing with, 681
   handles, 755, 868, 986
   IO::Dir module, 868
   opendir function, 755
   Perl modules for, 550
   prepending to @INC, 497
   reading entries from, 770
   rewinddir function, 777
   root, redefining, 692
   seekdir function, 780
disciplines, 753
   filehandles, setting up with binmode, 685
division (see multiplicative operators)
DNS (domain name service), 438
do, 90
   BLOCK, 112, 701
&nbs

Product Details

ISBN:
9780596000271
Author:
Wall, Larry
Author:
McLaughlin, Brett
Author:
O'Reilly Media
Author:
Christiansen, Tom
Author:
Wall, Larry
Author:
Orwant, Jon
Publisher:
O'Reilly Media
Location:
Beijing ;
Subject:
Programming - General
Subject:
Computer graphics
Subject:
Computers
Subject:
Programming Languages - Java
Subject:
Programming Languages - CGI, Javascript, Perl, VBScript
Subject:
Perl (computer program language)
Subject:
Object-oriented programming
Subject:
Perl
Subject:
Books; Computers & Internet; Internet & World Wide Web; Scripting & Programming; Perl
Subject:
Books; Computers & Internet; Networking & OS; Operating Systems; Unix; Programming
Subject:
Programming Languages - Perl
Subject:
General-General
Subject:
3rd;Jon Orwant;Larry Wall;Perl Programming;Perl debugging;Perl efficiency;Perl functions;Perl library;Perl syntax;Third Edition;Tom Christiansen;camel;camel book
Subject:
CourseSmart Subject Description
Subject:
3rd;Jon Orwant;Larry Wall;Perl Programming;Perl debugging;Perl efficiency;Perl functions;Perl library;Perl syntax;Third Edition;Tom Christiansen;camel;camel
Subject:
Book
Subject:
General Computers
Copyright:
Edition Number:
3
Edition Description:
Third Edition
Series:
O'Reilly Perl Series
Series Volume:
no. AK-RD-85-33
Publication Date:
20000724
Binding:
Paperback
Language:
English
Illustrations:
Yes
Pages:
1104
Dimensions:
9.19 x 7 x 1 in 3.04 lb

Other books you might like

  1. Perl Cookbook Used Trade Paper $14.95
  2. Advanced Perl Programming 1ST Edition Used Trade Paper $9.95
  3. Perl Cookbook Used Trade Paper $14.95
  4. Programming the Perl DBI: Database... Used Trade Paper $14.95
  5. Perl for System Administration Used Trade Paper $8.50

Related Subjects


Computers and Internet » Computer Languages » Javascript
Computers and Internet » Computer Languages » Perl

Programming Perl, 3rd Edition Used Trade Paper
0 stars - 0 reviews
$27.00 In Stock
Product details 1104 pages O'Reilly & Associates Inc. - English 9780596000271 Reviews:
"Synopsis" by , This text provides an introduction to the Perl programming language and its culture. This third edition has been expanded to cover Version 5.6 of Perl. New topics include threading, the compiler, and Unicode.
"Synopsis" by ,
This comprehensive guide gives readers the inside scoop to the nooks and crannies of the language. Expanded to cover version 5.6, new topics of "Programming Perl" include threading, the compiler, Unicode, and other new features that have been added since the previous edition.
"Synopsis" by , Perl programmers increasingly rely on the Web, online help, and other online information sources to cure information pain. Now O'Reilly's Perl CD Bookshelf gives you convenient online access to your favorite books from your CD-ROM drive.The Perl CD Bookshelf contains a powerhouse of O'Reilly Animal Guides. Included are complete, unabridged versions of Perl in a Nutshell; Programming Perl, 2nd Edition; Perl Cookbook;Advanced Perl Programming; Learning Perl; and Learning Perl on Win32 Systems. As a bonus, the hard-copy version of Perl in a Nutshell is also included.Never has it been easier to learn, or look up, what you need to know online. Formatted in HTML, The Perl CD Bookshelf can be accessed with any Web browser. The books are fully searchable and cross-referenced. In addition to individual indexes for each book, a master index for the entire library is provided.
spacer
spacer
  • back to top

FOLLOW US ON...

     
Powell's City of Books is an independent bookstore in Portland, Oregon, that fills a whole city block with more than a million new, used, and out of print books. Shop those shelves — plus literally millions more books, DVDs, and gifts — here at Powells.com.