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

Index: S

• -S file test operator: Named Unary and File Test Operators
• s for whitespace=\s (for whitespace): Regular Expressions
• s operator (see substitution operator)
• /s pattern modifier: Pattern Modifiers
• • The m// Operator (Matching)
  • The s/// Operator (Substitution)
  • The tr/// Operator (Transliteration)
• -S (search for script) command-line switch: Switches
• s// (substitution) operator: Universal Blunders
• -s (switch) command-line switch: Switches
• • The Perl Debugger
• safe compartments for insecure code: Safe Compartments
• Safe module: Safe Compartments
• • Authentication, Security, and Encryption
  • insecure code, handling with: Restricting operator access
  • • Safe Compartments
• save stack: Executing Your Code
• saving data structures: Saving Data Structures
• scalar context: Scalar and List Context
• • Boolean values and: Boolean Context
  • comma operator in: Comma Operators
  • • Previous Perl Traps
  • conditional operator in: Conditional Operator
  • expressions in (see EXPRs)
  • forcing: scalar
  • functions in: Functions
  • /g pattern modifier, use in: The m// Operator (Matching)
  • hash variables, evaluating in: Hashes
  • keys function, calling in: Hash-Tying Methods
  • list assignment in: List Assignment
  • • Assignment Operators
  • lvalues in: Scoped Variable Declarations
  • m// (match) operator in: The m// Operator (Matching)
  • operations behaving differently in: Frequently Ignored Advice
  • range (..) operator in: Range Operator
  • recognizing in debugger: Using the Debugger
  • subroutines, calling and evaluating in: Semantics
  • subtypes of: Scalar and List Context
  • void context: Void Context
• scalar pseudofunction: scalar
• scalar reverse function: Effects of Character Semantics
• scalar values: Scalar Values
• • Scalar Values
  • here documents: "Here" Documents
  • interpolating array values: Interpolating Array Values
  • numeric literals: Numeric Literals
  • operators fo: Unary and Binary Operators
  • string literals: String Literals
  • v-string literals: V-String Literals
• scalar variables
• • in angle brackets: Line Input (Angle) Operator
  • in double-quote context: The s/// Operator (Substitution)
• scalars: Variable Syntax
• • Singularities
  • Built-in Data Types
  • Variables
  • characters, length of: length
  • complex data structures, representing as: Complexities
  • constants: Symbol Tables
  • • Symbol Tables
    • (see also constants)
  • functions for manipulating: Perl Functions by Category
  • hard references as: What Is a Reference?
  • list of (see arrays)
  • lists, converting to: Complexities
  • parameter and return lists, subroutines: Semantics
  • pattern-matching operators, applying to: Pattern-Matching Operators
  • Perl, converting to C types: Evaluating a Perl Statement from C
  • references: Singularities
  • SV (scalar value) in C: Internal Data Types
  • truth, evaluating in: What Is Truth?
  • tying: Tying Scalars
  • • base class definitions, providing: Convenient Classes
    • magical counter variables: Magical Counter Variables
    • methods for: Scalar-Tying Methods
    • preventing unlocalized use of $_ variables: Magically Banishing $_
  • unordered set of (see hashes)
• scheduling and preemption policies, threads: The Thread Model
• scopes: Names
• • Compound Statements
  • dynamic: Dynamically Scoped Variables: local
  • block: Lexically Scoped Variables: my
  • blocks: Compound Statements
  • file: Lexically Scoped Variables: my
  • lexical scope: Lexically Scoped Variables: my
  • loop variable in foreach: foreach Loops
  • variables in if statements: if and unless Statements
  • variables in three-part for loops: for Loops
  • variables in while loops: while and until Statements
  • declarations and: Scoped Declarations
  • functions dealing with: Perl Functions by Category
  • lexically scoped variables: Names
  • my variables: Packages
  • package declarations: Packages
  • pattern-matching operations: Pattern-Matching Operators
  • private variables (see lexical variables)
  • scope modifiers: Scoped Variable Declarations
  • scope operators: Scoped Variable Declarations
  • scope stack: Executing Your Code
  • signal handling: Signals
  • static (see scopes; lexical)
  • subroutines: Scoping Issues
  • in threads: Queues
  • variables: Variable Syntax
  • • strict pragma and: Simplicities
• screen appearance of command line: Debugger Options
• scripts
• • building with -e switch: Switches
  • CGI, taint mode and: Handling Insecure Data
  • checking syntax of: Switches
  • debugging: Switches
  • • Switches
    • (see also debugging)
  • dumping core files: Switches
  • embedding in messages: Switches
  • end marker for: Other Literal Tokens
  • executing: system
  • insecure: Handling Insecure Code
  • interpretation, shells vs. Perl: Shell Traps
  • languages, checking for: Unicode block properties
  • names of (see $0 variable)
  • pausing: sleep
  • Perl
  • • common mistakes of novices: Common Goofs for Novices
    • CPAN directory of: CPAN
    • idiomatic Perl, using: Fluent Perl
    • performance of: Efficiency
    • perl interpreter, associating with: How to Do It
    • developing with style: Developing with Style
    • searching for and compiling: Command Processing
    • test scripts: Development Support
  • running time of: Named Unary and File Test Operators
  • searching for: Switches
  • terminating with exec: exec
• SDBM_File module: DBM Interfaces
• search and replace, global: The s/// Operator (Substitution)
• search path, %INC: Special Variables in Alphabetical Order
• search programs: Regular Expressions
• Search::Dict module: String Processing, Language Text Processing, Parsing, and Searching
• searching
• • grep function for: grep
  • linear, versus hashes: Time Efficiency
  • rules for name searches: Name Lookups
  • for scripts: Switches
  • for substrings: The s/// Operator (Substitution)
  • • index
    • rindex
  • text, Perl modules for: The CPAN modules Directory
• security: The Pursuit of Happiness
• • Security
  • srand
  • code masquerading as data: Code Masquerading as Data
  • insecure code, handling: Handling Insecure Code
  • • safe compartments for: Safe Compartments
  • insecure data, handling: Handling Insecure Data
  • • Handling Insecure Data
    • command and file access under reduced privileges: Accessing Commands and Files Under Reduced Privileges
    • detecting and laundering tainted data: Detecting and Laundering Tainted Data
    • environment, cleaning up: Cleaning Up Your Environment
  • modules for: Authentication, Security, and Encryption
  • • The CPAN modules Directory
  • timing glitches, handling: Handling Timing Glitches
  • • race conditions: Handling Race Conditions
    • temporary files: Temporary Files
    • Unix kernel security bugs: Unix Kernel Security Bugs
  • Win32::FileSecurity module: Microsoft-Related Modules
• security, of file test operators: use filetest

• sed: Regular Expressions

• The tr/// Operator (Transliteration)

• seed, random number: srand
• seek function: seek

• tell
• (see also tell function)

• SEEK method: Filehandle-Tying Methods
• seekable I/O objects: Filehandle, Directory Handle, and Stream I/O Utilities
• seekdir function: seekdir
• select function: fileno

• print
• select (output filehandle)
• select (ready file descriptors)
• Filehandle, Directory Handle, and Stream I/O Utilities
• for format variables: Format Variables
• • Format Variables

• select syscall, multiplexing I/O between clients: Networking Servers
• SelectSaver module: Filehandle, Directory Handle, and Stream I/O Utilities
• self-matching characters: The Little Engine That /Could(n't)?/
• self method, thread accessing own thread object: Identifying threads
• SelfLoader module: Autoloading

• Module Installation Support
• Devel::SelfStubber module, using with: Module Installation Support

• semantics: use
• semaphore file, use in file locking: File Locking

• System V IPC: System V IPC

• functions for: semctl
• IPC::Semaphore module: Networking and Interprocess Communication
• shared memory: System V IPC
• thread safety and: The Thread Model
• Thread::Semaphore module: Semaphores
• Win32::Semaphore module: Microsoft-Related Modules

• semctl function: semctl
• semget function: semget
• semop function: semop
• send function: send
• separators, split operator, defining: Regular Expressions
• sequential matches: The Little Engine That /Could(n't)?/
• serial ports, Perl modules for: The CPAN modules Directory
• serializing Perl data structures: Perl Language Extensions and Internals
• server-push CGI scripting: World Wide Web
• servers

• forking clones to handle incoming connections: Networking Servers
• networking: Networking Servers
• Perl modules for: The CPAN modules Directory
• taint mode, importance of enabling for: Handling Insecure Data
• TCP: Networking Clients

• service port name/number translations: getservbyname
• set-id program:
• Handling Insecure Data

• dangerous operations, UID and GID setting to real: Accessing Commands and Files Under Reduced Privileges
• Unix kernel bugs, security problems with: Unix Kernel Security Bugs

• setgid function: Talking to Yourself

• Handling Insecure Data

• setgrent function: getgrent
• sethostent function: gethostent
• setpgrp function: setpgrp

• Signaling Process Groups

• setpriority function: setpriority
• setprotoent function: getprotoent
• setpwent function: getpwent
• sets, intersection: Passing References
• setservent function: getservent
• setsockopt function: setsockopt
• setuid function: Talking to Yourself

• Handling Insecure Data

• shadow, password entries: getpwnam
• shared file locks: File Locking
• shared memory, System V IPC: System V IPC

• controlled access to: System V IPC
• functions for: shmctl

• # (sharp)

• for comments: Molecules
• • /x pattern modifier, using with: Pattern Modifiers
• in formats: Formats
• quoting character, whitespace and: Pick Your Own Quotes
• #! (shebang) notation: How to Do It
• • Command Processing
  • security problems caused by: Unix Kernel Security Bugs
  • simulating on non-Unix systems: #! and Quoting on Non-Unix Systems

• shell module: Operating System Interfaces

• alternative for Perl, Windows systems: Environment Variables
• avoiding use of: Accessing Commands and Files Under Reduced Privileges
• avoiding with multi-argument piped open: Anonymous Pipes
• Bourne shell (sh): Command Processing
• bypassing with -| piping pseudocommand: Talking to Yourself
• debugger commands and: Actions and Command Execution
• environment variables as security hazards: Cleaning Up Your Environment
• environment variables, using with: Environment Variables
• I/O streams, setting up: Filehandles
• pipe commands with shell metacharacters, passing to: open
• pipe commands with special characters, handling: Anonymous Pipes
• developing, Perl vs.: Shell Traps
• quotes, passing through: Switches
• security pitfalls with use, avoiding: Code Masquerading as Data
• spawning, characters for: Debugger Options

• shift function: Data Structures

• shift

• shift operator: The while and until statements

• Shift Operators
• Shift Operators

• shmctl function: shmctl
• ShMem package: System V IPC
• shmget function: shmget
• shmread function: shmread
• shmwrite function: shmwrite
• short-circuit operators: Logical Operators

• C-Style Logical (Short-Circuit) Operators
• overloading and: Overloadable Operators

• shortening arrays: Array Length
• shorts: sprintf
• shutdown function: shutdown
• shutdown syscall: Networking Clients
• %SIG hash: Signals

• Special Variables in Alphabetical Order

• sigaction function: Reaping Zombies
• SIGALRM signal: alarm
• signal handlers

• defining as strings: Packages
• %SIG, Perl vs. C language: Traps

• signal handling, sigtrap module: Operating System Interfaces
• signal level option (debugger): Debugger Options
• signals: Interprocess Communication

• Signals
• %SIG hash: Special Variables in Alphabetical Order
• blocking: Blocking Signals
• core dumps, triggering in C library: Signals
• killing processes with: kill
• portability of: System Interaction
• signaling process groups: Signaling Process Groups
• sources of: Signals
• threads, delivering to: The Thread Model
• Thread::Signal module: Other standard threading modules
• timing out slow operations: Timing Out Slow Operations
• trapping with sigtrap pragma: Signals
• zombie processes, reaping: Reaping Zombies

• sigprocmask syscall: Blocking Signals
• sigtrap pragma: Signals

• Signals

• sin function (sine): sin
• single inheritance: Class Inheritance
• single quotes (')

• contractions in words, avoiding confusion with: Lookaround Assertions
• as package delimiters: Packages
• pattern recompilation and: Pattern Modifiers
• suppressing interpolation: Singularities
• suppressing variable interpolation and translation escape processing: When backslashes happen

• singularities (see singularities)
• $size file statistic: stat
• sleep function: sleep

• select function instead of: select (ready file descriptors)

• slices of arrays or hashes: Variables
• slices of multidimensional arrays: Slices

• Perl, setting value for: Switches

• Socket module: Sockets

• Networking and Interprocess Communication
• inet_ntoa function: gethostbyaddr
• networking client, connecting to server: Networking Clients

• socketpair function: socketpair
• socketpair syscall: Bidirectional Communication
• sockets

• accepting connections from clients: accept
• attaching address to: bind
• closing: close
• closing one side: shutdown
• connecting: connect
• functions for: getsockname
• functions (Perl), dealing with: Sockets
• getting packed sockaddr address: getpeername
• in interprocess communication: Sockets
• • message passing: Message Passing
  • networking clients: Networking Clients
  • networking servers: Networking Servers
• listen function for: listen
• low-level access, functions for: Perl Functions by Category
• modules for: Networking and Interprocess Communication
• newlines, sending across: Newlines
• opening with socket function: socket
• protocols and: Interprocess Communication
• receiving messages on: recv
• sending messages on: send
• setting options: setsockopt
• shutting down connection: shutdown
• TCP and: Sockets
• Unix-domain sockets: Sockets

• sort variables: Special Variables in Alphabetical Order
• sort function: List Processing
• sort subroutines, comparison operators in: Some Numeric and String Comparison Operators
• sorting

• arrays in hashes of: Access and Printing of a Hash of Arrays
• hashes: Access and Printing of a Hash of Hashes
• keys and values, hashes: keys
• lists: sort
• overloading and: Overloadable Operators
• sort function: sort

• sort( ), keys, lists of: Hashes.
• source code

• CPAN, for Perl distribution: CPAN
• development tools for: Code Development Tools
• filter for: The Bytecode Generator
• filters for: Source Filters
• foreign code, executing: Security
• window around breakpoint, examining: Using the Debugger

• source filters: The CPAN modules Directory
• space: Molecules
• spaceship operator (<=>): Equality Operators
• special characters: The Little Engine That /Could(n't)?/
• special variables: Per-Package Special Functions
• speed (see also performance)

• Efficiency

• splice function: splice

• Perl versions, changes in: Previous Perl Traps

• splicing tied arrays: Array-Tying Methods
• split function: Regular Expressions

• Pattern-Matching Operators
• Clustering
• Time Efficiency
• split

• sprintf function: Filehandle-Tying Methods

• sprintf

• sqrt function (square root): sqrt
• srand function: srand
• src directory (CPAN): CPAN
• stacks: Arrays.

• Data Structures
• expression evaluation: Built-in Data Types
• backtracing with T command: Using the Debugger
• disciplines: open
• Perl, manipulating from C: Fiddling with the Perl Stack from C
• Perl virtuall machine: Executing Your Code
• subroutines, current calls: caller

• standard input, scripts, passing by: Command Processing
• standard Unicode properties: Standard Unicode properties
• star (see asterisk)
• starting position of matched string: Special Variables in Alphabetical Order
• stat, file permissions as octal: oct
• stat function: stat

• Filenames, Filesystems, and File Locking
• filehandles, calling on: Handling Race Conditions

• state

• common, sharing by class objects: Managing Class Data
• inheritance with class data accessor methods: Managing Class Data

• statements: Statements and Declarations

• compound: Compound Statements
• global declarations and: Global Declarations
• if and unless: if and unless Statements
• labels for (see labels)
• loop-control operators vs.: Loop Control
• loops (see loops)
• Perl, evaluating from C: Evaluating a Perl Statement from C
• simple: Simple Statements

• static linking: XS and XSUBs
• static scoping (see lexical scope)
• static variables: Scoping Issues
• statistics, Perl modules for: The CPAN modules Directory
• status of exiting process: Special Variables in Alphabetical Order
• STDERR filehandle: Developing with Style

• Special Variables in Alphabetical Order
• fileno

• STDIN filehandle: Special Variables in Alphabetical Order

• STDIN: Filehandles
• fileno
• reading single characters from: getc

• STDIN, STDOUT, and STDERR filehandles: Passing Filehandles

• passing filehandles to new programs through: Passing Filehandles
• reassigning to client connection: Networking Servers

• STDOUT filehandle: Special Variables in Alphabetical Order

• STDOUT: Filehandles
• fileno
• printing to: print

• stemming text, Perl modules for: The CPAN modules Directory
• stepping through code: Stepping and Running
• sticky bit: Time Efficiency
• stopping (see terminating)

• infinite loop: for Loops

• storage locations

• for bytes (see big endian; little endian)
• lvalues for: Assignment Operators
• • (see also lvalues)

• storing complex data values in DBM file: Tie Modules on CPAN
• strict module: Simplicities

• Perl Language Extensions and Internals

• strict pragma: Name Lookups

• Controlling the Use of Globals
• Symbolic References

• string context: Scalar and List Context
• string literals: String Literals

• newlines in: String Literals
• v-strings (vector or version): V-String Literals

• stringification: Overloadable Operators

• modules for: Data::Dumper

• stringifying

• data structures: Saving Data Structures
• objects: Other Tricks You Can Do with Hard References
• references: Other Tricks You Can Do with Hard References
• • References Don't Work as Hash Keys
  • Access and Printing
  • Common Mistakes

• stringifying operator

• overloading: Filehandle-Tying Methods

• strings: Variable Syntax

• binary (see binary numbers)
• bitwise operators, working with: Bitwise Operators
• boundary assertions: Nailing Things Down
• • Beginnings: The \A and ^ Assertions
• capitalization of (see capitalization)
• comparing: Relational Operators
• comparison operators: Some Numeric and String Comparison Operators
• as compilation units: Name Lookups
• concatenating: Additive Operators
• • Time Efficiency
• containing newlines, matches against: Pattern Modifiers
• converting to list values: unpack
• converting to numbers:of: Numeric Literals
• display, changing in debugger: Debugger Options
• double-quoted
• • changes in Perl versions: Previous Perl Traps
  • character interpolation in: String Literals
• eval function and: Time Efficiency
• extracting substrings: substr
• first character of: Special Variables in Alphabetical Order
• formats for: sprintf
• hexadecimal (see hexadecimal numbers)
• index function: index
• joining: join
• list values, converting to: pack
• modifying: Modifying strings en passant
• numbers, converting to: Scalar Values
• octal (see octal numbers)
• operators: String Operators
• • Universal Blunders
• printing: print
• printing values in: Other Tricks You Can Do with Hard References
• quoted: Singularities
• range operator, working with: Range Operator
• references and: References Don't Work as Hash Keys
• rindex function: rindex
• searching for and replacing substrings (s/// operator): The s/// Operator (Substitution)
• splitting into substrings: split
• study function and: study
• truth values of: What Is Truth?
• vec function and: vec

• stripping (see deleting characters)
• Struct::Class module: Managing Instance Data
• structs

• emulating: Generating Classes with Class::Struct
• formatting: pack

• structural metacharacters in regular expressions: The Regular Expression Bestiary
• structural metasymbols: Metasymbol Tables
• StrVal (overload::StrVal): Public Overload Functions
• stubs for modules, generating: Module Installation Support
• study function: study
• style, developing with: Developing with Style
• sub {}: Bare Blocks
• sub declaration: The anonymous subroutine composer

• sub

• sub keyword: Syntax

• Prototypes

• subarrays and subhashes, references to, in arrays: Arrays.
• subclasses: Brief Refresher on Object-Oriented Lingo

• attributes, overriding superclass ancestors: Managing Instance Data

• subnamespaces, for variables: Names
• subroutine call stack: caller
• subroutine calls, executing without stepping through: Stepping and Running
• subroutines: Variable Syntax

• Subroutines
• Subroutines
• Perl's Object System
• arguments: Special Variables in Alphabetical Order
• aborting with exit: exit
• anonymous references to: The anonymous subroutine composer
• atrributes, getting and setting: Perl Language Extensions and Internals
• autoloading: Autoloading
• • Method Autoloading
  • Module Installation Support
• barewords, confusing with: Previous Perl Traps
• B::Xref module, cross-references with C: Code Development Tools
• calling indirectly: Syntax
• calling, method invocations vs.: Inheritable Constructors
• classes with same names: Package-Quoted Classes
• constant: Symbol Tables
• data, passing into and out of: Semantics
• debugger command for pattern match listings: Locating Code
• declaring: Global Declarations
• • sub
• declaring in package for AUTOLOAD management: Method Autoloading
• defining: Semantics
• definitions, loading from other files: Global Declarations
• do SUBROUTINE operator: do (subroutine)
• errors, indicating: Error Indications
• external, portability of: External Subroutines (XS)
• external (XSUBs): Extending Perl (Using C from Perl)
• importing from another module: Syntax
• lexically scoped: my
• locking for threads: Locking subroutines
• • locked attribute: The locked attribute
• lvalue attribute: New Tricks
• method resolution, steps for: Class Inheritance
• methods vs.: Method Invocation
• named, compiler/interpreter interaction: Avant-Garde Compiler, Retro Interpreter
• names for: Names
• • Names
• names of: Syntax
• nested: Nested subroutines
• parameter lists, working with: Tricks with Parameter Lists
• passing references in: Passing References
• performance and: Time Efficiency
• Perl, calling from C: Calling a Perl Subroutine from C
• prototyping, careful use of: Care with Prototypes
• redefining, inlining and: Inlining Constant Functions
• references to, retrieving from or passing to: Symbol Tables
• references to, in scalars: Singularities
• return function: return
• return values: Semantics
• returning references: Object Constructors
• scoping issues: Scoping Issues
• sorting, reverse disallowed as name for: Previous Perl Traps
• substituting with goto: goto
• • goto
• timelocal: localtime
• user-defined: Verbs

• subs module: Perl Language Extensions and Internals
• subs pragma, overriding built-in functions with: Overriding Built-in Functions
• $SUBSCRIPT_SEPARATOR: Hashes

• Special Variables in Alphabetical Order

• subscripting: Time Efficiency

• negative: Built-in Data Types

• subscripts, arrays: Arrays.
• subshells, environment variables, using with: Environment Variables
• substitute (s//) operator: Universal Blunders

• Pattern Matching
• Interpolative Context
• Pattern-Matching Operators

• substitution evaluations: Substitution evaluations
• substitution, shells versus Perl: Shell Traps
• substr function: Time Efficiency

• substr
• chop function and: chop
• manipulating string positions with: Positions

• searching for and replacing with s/// operator: The s/// Operator (Substitution)

• subtracting, from character sets: Defining your own character properties
• subtracting pattern modifiers from cloisters: Cloistered Pattern Modifiers
• subtraction (see also additive operators)

• overloaded objects: Overload Handlers

• SUPER pseudoclass: Accessing Overridden Methods

• Accessing Overridden Methods

• superclasses: Brief Refresher on Object-Oriented Lingo
• SV (internal scalar value): Internal Data Types
• SWIG: XS and XSUBs
• SWIG system, XSUBs, automatically generating: XS and XSUBs
• switch statement: Case Structures

• Time Efficiency
• Perl vs. C developing: Traps

• switches, command-line: Command Processing

• Switches
• -e switches: Command Processing
• default, taking switches as: Environment Variables
• single character, processing with clustering: Option, Argument, Parameter, and Configuration File Processing

• Sx, Perl modules for: The CPAN modules Directory
• symbol tables: Names

• Names
• Symbol Tables
• containing references to other symbol tables: Symbol Tables
• current package, determining use of: Packages
• displaying for packages: Debugger Options
• entries, aliasing: Typeglobs and Filehandles
• format name identifiers in: format
• in fully qualified names: Names
• local operator, making temporary changes with: Dynamically Scoped Variables: local
• packages: package
• references to: Symbol Table References
• Symbol module: Data Types
• symbolic references naming entries in: What Is a Reference?

• (see also debugging)

• symbolic dereferences, checking with strict pragma: Controlling the Use of Globals
• symbolic links: symlink

• getting filenames from: readlink
• lstat function and: lstat
• security risks in Unix: Unix Kernel Security Bugs

• symbolic references: What Is a Reference?

• Symbolic References

• symbols

• exporting, prevention of Managing unknown symbols
• exporting from modules: Creating Modules
• importing into current package: Using Modules
• leaving off export list or deleting from import list: Module Privacy and the Exporter
• metasymbols, generic wildcards: Wildcard Metasymbols

• symlink function: symlink

• data access in threads: Synchronizing access with lock

• syntax, checking: Switches
• syntax, Perl: Built-in Data Types
• syscall function: alarm

• syscall

• ioctl and fcntl returns: ioctl
• performance and: Time Efficiency
• Perl, C language vs.: Traps
• restarting: Timing Out Slow Operations
• signal interruption of: Reaping Zombies

• Sys::Hostname module: Operating System Interfaces
• syslog, filehandle tying to: Tie Modules on CPAN
• sysopen function: File Locking

• Named Pipes
• open
• sysopen
• file overwriting, controlling: Handling Race Conditions

• sysread function: Filehandle-Tying Methods

• sysread

• Sys::Syslog module: Operating System Interfaces
• system calls: syscall
• system function: system

• list argument form, avoiding shell with: Code Masquerading as Data
• performance and: Time Efficiency
• portability of: Interprocess Communication (IPC)

• System V IPC: System V IPC

• functions dealing with: Perl Functions by Category
• functions for semaphores: semctl
• IPC::SysV module: Networking and Interprocess Communication
• killing proces groups: kill
• messages, syscalls for: msgctl
• portability of: Interprocess Communication (IPC)
• shared memory, functions for: shmctl

• System V IPC syscalls: Interprocess Communication

• reliable signals, not supporting: Reaping Zombies

• $SYSTEM_FD_MAX: Special Variables in Alphabetical Order
• syswrite function: Tying Filehandles

• Filehandle-Tying Methods
• syswrite

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