• Abstract for Language Environment Programming Guide
    • Summary of changes
      • Summary of changes
      • z/OS Version 2 Release 1 summary of changes
  • Creating applications with Language Environment
    • Introduction to Language Environment
      • Components of Language Environment
      • Common runtime environment of Language Environment
    • Preparing to link-edit and run under Language Environment
      • Understanding Language Environment library routines
        • Planning to link-edit and run
        • Link-editing single-language applications
        • Link-editing ILC applications
      • Downward compatibility considerations
      • Checking which runtime options are in effect
      • HLL compatibility considerations
      • C/C++ AMODE/RMODE considerations
      • COBOL considerations
        • Replacing COBOL library routines in a COBOL load module
        • Using Language Environment resident routines for callable services
      • Fortran considerations
        • Replacing Fortran runtime library modules in a Fortran executable program
        • Using the Fortran library module replacement tool
        • Resolving static common block name conflicts
        • Resolving library module name conflicts between Fortran and C
          • Conditions under which your application does not have a name conflict
          • Determining if your application has a name conflict
          • Removing Fortran conflicting references
            • Changing one module per step (MVS)
            • Changing one module per step (TSO/E)
            • Changing multiple modules per step (MVS)
            • Changing multiple modules per step (TSO/E)
          • Relink-editing a pre-Language Environment executable program
      • PL/I considerations
        • Link-editing PL/I subroutines for later use
        • Replacing PL/I library routines in an OS PL/I executable program
        • Link-editing fetchable executable programs
        • PL/I link-time considerations
        • Fetching modules with different AMODEs
    • Using Extra Performance Linkage (XPLINK)
      • What is XPLINK?
        • Objectives
        • Support for XPLINK
        • XPLINK concepts and terms
        • The XPLINK stack
          • The XPLINK stack frame layout
            • Save area (48 bytes)
            • Reserved (8 bytes)
            • Argument area prefix (4 bytes)
            • Argument area (minimum 16 bytes)
            • Local storage
            • Total stack frame size
          • Stack overflow
          • XPLINK register conventions
          • XPLINK parameter passing and return code conventions
      • When XPLINK should be used
        • When XPLINK should not be used
      • How is XPLINK enabled?
        • XPLINK compiler option
        • XPLINK runtime option
          • Related runtime options
      • Building and running an XPLINK application
        • Other considerations
      • XPLINK / non-XPLINK compatibility
      • XPLINK restrictions
    • Building and using dynamic link libraries (DLLs)
      • Support for DLLs
      • DLL concepts and terms
      • Loading a DLL
        • Loading a DLL implicitly
        • Loading a DLL explicitly
          • Explicit use of a DLL in a C application
          • Explicit use of a DLL in a COBOL/C application
      • Managing the use of DLLs when running DLL applications
        • Loading DLLs
        • Sharing DLLs
        • Freeing DLLs
      • Creating a DLL or a DLL application
      • Building a simple DLL
        • Writing DLL code
          • Writing your C DLL code
          • Writing your C++ DLL code
          • Writing your COBOL DLL code
          • Writing your Enterprise PL/I DLL code
          • Writing your Language Environment-conforming assembler DLL code
        • Compiling your DLL code
        • Binding your DLL code
          • Binding C
          • Binding C++
          • Binding COBOL
          • Binding Enterprise PL/I
          • Binding Assembler
      • Building a simple DLL application
      • Creating and using DLLs
      • DLL restrictions
        • Improving performance
      • Building complex DLLs
    • Link-editing, loading, and running under batch
      • Basic link-editing and running under batch
        • Accepting the default runtime options
        • Overriding the default runtime options
        • Specifying runtime options with the CEEOPTS DD card
        • Specifying runtime options in the EXEC statement
      • Providing link-edit input
        • Writing JCL for the link-edit process
        • Binder control statements
          • Using the INCLUDE statement
          • Using the LIBRARY statement
      • Link-edit options
      • Loading your application using the loader
        • Writing JCL for the loader
        • Invoking the loader with the EXEC statement
        • Using the PARM parameter for loader options
        • Requesting loader options
        • Passing parameters through the loader
        • Using DD statements for the standard loader data sets
      • Running an application under batch
        • Program library definition and search order
      • Specifying runtime options under batch
    • Creating and executing programs under TSO/E
      • Basic link-editing and running under TSO/E
        • Accepting the default runtime options
        • Overriding the default runtime options
        • Specifying runtime options with the CEEOPTS DD card
      • Link-editing and running
      • Link-editing your application using the LINK command
      • Using CMOD CLIST to invoke the TSO/E LINK command
      • Using the CALL command to run your application
        • TSO/E parameter list format
      • Loading and running using the LOADGO command
        • Allocating data sets under TSO/E
        • Example of using LOADGO
        • Link-edit and loader options
      • Using the iconv utility and ICONV CLIST for C/C++
      • Using the genxlt utility and GENXLT CLIST for C/C++
      • Running your application under TSO/E
    • Creating and executing programs using z/OS UNIX System Services
      • Basic link-editing and running C/C++ applications under z/OS UNIX
      • Invoking a shell from TSO/E
      • Using the z/OS UNIX c89 utility to link-edit and create executable files
      • Running z/OS UNIX C/C++ application programs
        • z/OS UNIX application program environments
        • Placing an MVS application executable program in the file system
        • Restriction on using 24-Bit AMODE programs
        • Running an MVS executable program from a z/OS UNIX shell
        • Running POSIX-enabled programs
          • Running POSIX-enabled programs using a z/OS UNIX shell
            • Issuing the executable from a shell
            • Issuing a setup shell script from a shell
          • Running an MVS batch z/OS UNIX C/C++ application file that is HFS-resident
          • Running POSIX-enabled programs outside the z/OS UNIX shells
          • Invoking BPXBATCH from TSO/E
          • Invoking BPXBATCH using JCL
          • Invoking the spawn syscall in a REXX EXEC from TSO/E
          • Running a z/OS UNIX C/C++ application program that is not HFS-resident
      • Running COBOL programs under z/OS UNIX
      • Basic link-editing and running PL/I routines under z/OS UNIX with POSIX(ON)
      • Basic link-editing and running PL/I MTF applications under z/OS UNIX
    • Using IBM-supplied cataloged procedures
      • Invoking cataloged procedures
        • Step names in cataloged procedures
        • Unit names in cataloged procedures
        • Data set names in cataloged procedures
      • IBM-supplied cataloged procedures
        • CEEWG — Load and run a Language Environment conforming non XPLINK program
        • CEEWL — Link a Language Environment conforming non XPLINK program
        • CEEWLG — Link and run a Language Environment conforming non-XPLINK program
        • CEEXR — Load and run a Language Environment conforming XPLINK program
        • CEEXL — Link-edit a Language Environment conforming XPLINK program
        • CEEXLR — Link and run a Language Environment conforming XPLINK program
        • AFHWL — Link a program written in Fortran
        • AFHWLG — Link and run a program written in Fortran
        • AFHWN — Resolving name conflicts between C and Fortran
      • Modifying cataloged procedures
        • Overriding and adding to EXEC statements
        • Overriding and adding DD statements
        • Overriding generic link-edit procedures for constructed reentrant programs
    • Using runtime options
      • Methods available for specifying runtime options
      • Order of precedence
        • Order of precedence examples
      • Specifying suboptions in runtime options
      • Specifying runtime options and program arguments
      • Creating application-specific runtime option defaults with CEEXOPT
        • CEEXOPT invocation for CEEUOPT
        • CEEXOPT coding guidelines for CEEUOPT
          • Performance considerations
      • Using the CEEOPTS DD statement
      • Runtime compatibility considerations
        • C and C++ compatibility considerations
        • COBOL compatibility considerations
        • Fortran compatibility considerations
        • PL/I compatibility considerations
        • IMS compatibility considerations
  • Preparing an application to run with Language Environment
    • Using Language Environment parameter list formats
      • Argument lists and parameter lists
      • Passing arguments between routines
      • Preparing your main routine to receive parameters
        • PL/I argument passing considerations
    • Making your application reentrant
      • Making your C/C++ program reentrant
        • Natural reentrancy
        • Constructed reentrancy
        • Generating a reentrant program executable for C or C++
      • Making your COBOL program reentrant
      • Making your Fortran program reentrant
      • Making your PL/I program reentrant
      • Installing a reentrant load module
  • Language Environment concepts, services, and models
    • Initialization and termination under Language Environment
      • The basics of initialization and termination
      • Language Environment initialization
        • What happens during initialization
      • Language Environment termination
        • What causes termination
        • What happens during termination
          • Thread termination
            • POSIX thread termination
          • Enclave termination
          • Process termination
            • POSIX process termination
      • Managing return codes in Language Environment
        • How the Language Environment enclave return code is calculated
          • C considerations
          • Fortran considerations
          • PL/I considerations
        • Setting and altering user return codes
          • For C and C++
          • For COBOL
          • For Fortran
          • For PL/I
          • How the enclave reason code is calculated
      • Termination behavior for unhandled conditions
        • Determining the abend code
          • Abend codes generated by CEEBXITA
          • Abend codes generated by ABTERMENC(ABEND) runtime option
          • Program interrupt abend and reason codes
    • Program management model
      • Model terminology for Language Environment program management
        • Language Environment terms and their HLL equivalents
        • Terminology for data
      • Processes
      • Enclaves
        • The enclave defines the scope of language semantics
          • The enclave defines the scope of the definition of the main routine and subroutines
          • The enclave defines the scope and visibility of the following types of data
          • The enclave defines the scope of language statements
        • Additional enclave characteristics
          • Management of resources
          • Multiple enclaves
      • Threads
      • The full Language Environment program management model
      • Mapping the POSIX program management model to the Language Environment program management model
        • Key POSIX program entities and Language Environment counterparts
        • Scope of POSIX semantics
    • Stack and heap storage
      • How Language Environment-conforming languages uses stack and heap storage
      • Stack storage overview
        • Tuning stack storage
        • COBOL storage considerations
        • PL/I storage considerations
      • Heap storage overview
        • Using HEAPPOOLS to improve performance
          • Applications which should use heap pools
          • Heap pools modes of operation
          • Choosing the number of pools for a cell size
        • Heap IDs recognized by the Language Environment heap manager
        • AMODE considerations for heap storage
        • Tuning heap storage
      • Storage performance considerations
      • Dynamic storage services
      • Examples of callable storage services
        • C example of building a linked list
        • COBOL example of building a linked list
        • PL/I example of building a linked list
        • C example of storage management
        • COBOL example of storage management
        • PL/I example of storage management
      • User-created heap storage
      • Alternative Vendor Heap Manager
        • Using _CEE_HEAP_MANAGER to invoke the alternative Vendor Heap Manager
    • Introduction to Language Environment condition handling
      • Concepts of Language Environment condition handling
      • The stack frame model
        • Handle cursor
        • Resume cursor
      • What is a condition in Language Environment?
      • Steps in condition handling
        • Enablement step
          • TRAP effects on the condition handling process
            • CEESGL and TRAP
          • Language Environment abends and the enablement step
          • Using CEE3SPM and XUFLOW to enable and disable hardware conditions
            • C and C++ considerations
            • COBOL considerations
            • Fortran considerations
            • PL/I considerations
        • Condition step
          • Influencing condition handling with the ERRCOUNT runtime option
        • Termination imminent step
          • Processing the T_I_U condition
          • Processing the T_I_S condition
          • Termination imminent step and the TERMTHDACT runtime option
            • PL/I considerations
          • CEESGL and the termination imminent step
      • Invoking condition handlers
      • Responses to conditions
      • Condition handling scenarios
        • Scenario 1: Simple condition handling
        • Scenario 2: User-written condition handler present for T_I_U
        • Scenario 3: Condition handler present for divide-by-zero
    • Language Environment and HLL condition handling interactions
      • C condition handling semantics
        • Comparison of C-Language Environment terminology
        • Controlling condition handling in C
          • Using the signal() function
          • Using the raise() function
          • C atexit() considerations
        • C condition handling actions
          • C condition handling examples
            • Condition occurs with no signal handler present
            • Condition occurs with signal handler present
        • C signal representation of S/370 exceptions
      • C++ condition handling semantics
      • COBOL condition handling semantics
        • COBOL condition handling examples
        • Resuming execution after an IGZ condition occurs
        • Resuming execution after a COBOL STOP RUN statement
        • Reentering COBOL programs after stack frame collapse
        • Handling fixed-point and decimal overflow conditions
      • Fortran Condition handling semantics
        • Arithmetic program interruptions from vector instructions
        • Restrictions on using vector instructions in user-written condition handlers
      • PL/I condition handling semantics
        • PL/I condition handling actions
        • Promoting conditions to the PL/I ERROR condition
        • Mapping non-PL/I conditions to PL/I conditions
        • Additional PL/I condition handling considerations
        • PL/I condition handling example
      • Language Environment and POSIX signal handling interactions
        • Synchronous POSIX signal and Language Environment condition handling interactions
          • Enablement step for signals under z/OS UNIX
          • Condition step for POSIX signals under Language Environment
          • Termination imminent step under z/OS UNIX
          • POSIX signals that do not enter condition handling
    • Coding a user-written condition handler
      • PL/I considerations
        • Invocation of a procedure registered as a user handler
      • Types of conditions you can handle
      • User-written condition handler interface
      • Registering user-written condition handlers using USRHDLR
      • Nested conditions
        • Nested conditions in applications containing a COBOL program
        • Using Language Environment condition handling with nested COBOL programs
      • Examples with a registered user-written condition handler
        • Handling a divide-by-zero condition in C, C++, COBOL, or PL/I
          • C or C++ handling a divide-by-zero condition
          • COBOL handling a divide-by-zero condition
            • USRHDLR program (COBOL)
          • PL/I handling a divide-by-zero condition
        • Handling an out-of-storage condition in C, C++, COBOL, or PL/I
          • C/C++ examples using CEEHDLR, CEEGTST, CEECZST, and CEEMRCR
          • COBOL examples using CEEHDLR, CEEGTST, CEECZST, and CEEMRCR
          • PL/I examples using CEEHDLR, CEEGTST, CEECZST, and CEEMRCR
        • Signaling and handling a condition in a C/C++ routine
        • Handling a divide-by-zero condition in a COBOL program
        • Handling a program check in an assembler routine
    • Using condition tokens
      • The basics of using condition tokens
      • The effect of coding the fc parameter
        • Testing a condition token for success
        • Testing condition tokens for equivalence
        • Testing condition tokens for equality
      • Effects of omitting the fc parameter
      • Understanding the structure of the condition token
      • Using symbolic feedback codes
        • Locating symbolic feedback codes for conditions
        • Including symbolic feedback code files
        • Examples using symbolic feedback codes
          • C and C++
          • COBOL
          • PL/I
      • Condition tokens for C signals under C and C++
      • q_data structure for abends
        • Usage notes
        • Example illustrating retrieval of q_data
      • q_data structure for arithmetic program interruptions
        • Usage notes
      • q_data structure for square-root exception
      • q_data structure for math and bit-manipulation conditions
        • Usage notes
      • Format of q_data descriptors
    • Using and handling messages
      • How Language Environment messages are handled
      • Creating messages
        • Creating a message source file
        • Using the CEEBLDTX utility
          • z/OS UNIX interface
          • TSO/E interface
        • Files created by CEEBLDTX
          • CEEBLDTX error messages
            • Return Code=-1
        • Creating a message module table
        • Assigning values to message inserts
      • Interpreting runtime messages
      • Specifying national languages
      • Runtime messages with POSIX
      • Handling message output
        • Using Language Environment MSGFILE
        • Using MSGFILE under z/OS UNIX
        • Using C or C++ I/O functions
        • Using COBOL I/O statements
          • Non-CICS considerations
          • CICS considerations
        • Using Fortran I/O statements
        • Using PL/I I/O statements
        • MSGFILE considerations when using PL/I
      • Examples using multiple message handling callable services
        • C/C++ example calls to CEEMOUT, CEENCOD, CEEMGET, CEEDCOD, and CEEMSG
        • COBOL example calls to CEEMOUT, CEENCOD, CEEMGET, CEEDCOD, and CEEMSG
        • PL/I example calls to CEEMOUT, CEENCOD, CEEMGET, CEEDCOD, and CEEMSG
    • Using date and time services
      • The basics of using date and time services
      • Working with date and time services
        • Date limits
        • Picture character terms and picture strings
        • Notation for eras
      • Performing calculations on date and time values
      • Century window routines
      • National Language Support for date and time services
      • Examples using date and time callable services
        • Examples illustrating calls to CEEQCEN and CEESCEN
          • Calls to CEEQCEN and CEESCEN in C or C++
          • Calls to CEEQCEN and CEESCEN in COBOL
          • Calls to CEEQCEN and CEESCEN in PL/I
        • Examples illustrating calls to CEESECS
          • Calls to CEESECS in C or C++
          • Calls to CEESECS in COBOL
          • Calls to CEESECS in PL/I
        • Examples illustrating calls to CEESECS and CEEDATM
          • Calls to CEESECS and CEEDATM in C or C++
          • Calls to CEESECS and CEEDATM in COBOL
          • Calls to CEESECS and CEEDATM in PL/I
        • Examples illustrating calls to CEESECS, CEESECI, CEEISEC, and CEEDATM
          • Calls to CEESECS, CEESECI, CEEISEC, and CEEDATM in C or C++
          • Calls to CEESECS, CEESECI, CEEISEC, and CEEDATM in COBOL
          • Calls to CEESECS, CEESECI, CEEISEC, and CEEDATM in PL/I
        • Examples illustrating calls to CEEDAYS, CEEDATE, and CEEDYWK
          • Calls to CEEDAYS, CEEDATE, and CEEDYWK for C or C++
          • Calls to CEEDAYS, CEEDATE, and CEEDYWK in COBOL
          • Calls to CEEDAYS, CEEDATE, and CEEDYWK in PL/I
        • Calls to CEECBLDY in COBOL
    • National language support
      • Customizing Language Environment output for a given country
      • Setting the national language
      • Setting the country code
      • Euro support
      • Combining national language support and date and time services
        • Calls to CEE3CTY, CEEFMDT, and CEEDATM in C
        • Calls to CEE3CTY, CEEFMDT, and CEEDATM in COBOL
        • Example using CEE3CTY, CEEFMDT, and CEEDATM in PL/I
    • Locale callable services
      • Customizing Language Environment locale callable services
      • Developing internationalized applications
      • Examples of using locale callable services
        • Example calls to CEEFMON
          • Calls to CEEFMON in COBOL
          • Calls to CEEFMON in PL/I
        • Example calls to CEEFTDS
          • Calls to CEEFTDS in COBOL
          • Calls to CEEFTDS in PL/I
        • Example calls to CEELCNV and CEESETL
          • Calls to CEELCNV and CEESETL in COBOL
          • Calls to CEELCNV and CEESETL in PL/I
        • Example calls to CEEQDTC and CEESETL
          • Calls to CEEQDTC and CEESETL in COBOL
          • Calls to CEEQTDC and CEESETL in PL/I
        • Example calls to CEESCOL
          • Calls to CEESCOL in COBOL
          • Calls to CEESCOL in PL/I
        • Example calls to CEESETL and CEEQRYL
          • Calls to CEESETL and CEEQRYL in COBOL
          • Calls to CEESETL and CEEQRYL in PL/I
        • Example calls to CEEQRYL and CEESTXF
          • Calls to CEEQRYL and CEESTXF in COBOL
          • Calls to CEEQRYL and CEESTXF in PL/I
    • General callable services
      • List of the general callable services
        • CEE3DMP callable service
          • Specifying a target directory for CEEDUMPs
        • CEE3USR callable service
        • CEEGPID callable service
        • CEEGTJS callable service
        • CEERAN0 callable service
        • CEEENV callable service
        • CEE3DLY callable service
        • CEEDLYM callable service
        • CEETEST callable service
      • Using basic callable services
    • Math services
      • What Language Environment math services does
        • Related services
      • Call interface to math services
        • Parameter types: parm1 type and parm2 type
      • Examples of calling math services
        • Calling CEESSLOG in C and C++
        • Calling CEESSLOG in COBOL
        • Calling CEESSLOG in PL/I
  • Using interfaces to other products
    • Running applications under CICS
      • Terminology used in the Language Environment program model
        • CICS region
        • CICS transaction
        • CICS run unit
        • Running Language Environment applications under CICS
      • Developing an application under CICS
        • PL/I coding considerations under CICS
        • Assembler considerations
        • Link-edit considerations under CICS
          • C and C++ considerations
          • COBOL considerations
          • PL/I considerations
        • CICS processing program table (PPT) considerations
        • Specifying runtime options under CICS
        • Accessing DLI databases from CICS
        • Using callable services under CICS
        • OS/VS COBOL compatibility considerations under CICS
        • Using math services in PL/I under CICS
        • Coding program termination in PL/I under CICS
      • Storage management under CICS
        • CICS short-on-storage condition
        • CICS storage protect facility
        • PL/I storage considerations under CICS
          • Initializing static external data
          • PL/I object program size
          • Using CICS storage constructs instead of PL/I language statements
          • PL/I storage classes
            • Using PUT DATA with BASED storage
          • Using STORAGE built-in functions
      • Condition handling under CICS
        • PL/I considerations for using the CICS HANDLE ABEND command
        • Effect of the CICS HANDLE ABEND command
        • Effect of the CICS HANDLE CONDITION and CICS HANDLE AID
        • Restrictions on user-written condition handlers under CICS
          • COBOL considerations
        • CICS transaction abend codes
        • Using the CBLPSHPOP runtime option under CICS
        • Restrictions on assembler user exits under CICS
          • PL/I considerations
        • Ensuring transaction rollback under CICS
      • Runtime output under CICS
        • Message handling under CICS
          • PL/I SYSPRINT
          • CICS XPLINK SYSPRINT
        • Dump services under CICS
          • PL/I considerations
      • Support for calls within the same HLL under CICS
        • C
        • C++
        • COBOL
          • Language Environment-conforming COBOL
          • VS COBOL II
          • OS/VS COBOL
        • PL/I
    • Running applications under DB2
      • Language Environment support for DB2 applications
      • Condition handling under DB2
      • PL/I consideration for DB2 applications
    • Running applications under IMS
      • Using the interface between Language Environment and IMS
      • z/OS XL C/C++ considerations under IMS
      • C++ considerations under IMS
      • PL/I considerations under IMS
      • IMS communication with your application
        • Link-edit considerations under IMS
      • Making your IMS application reentrant
      • Condition handling under IMS
        • Coordinated condition handling under IMS
        • Diagnosing abends with the IMS dump
  • Specialized programming tasks
    • Using runtime user exits
      • User exits supported under Language Environment
        • Using the assembler user exit CEEBXITA
        • Using the HLL initialization exit CEEBINT
        • PL/I and C compatibility
        • Using sample assembler user exits
      • When user exits are invoked
        • CEEBXITA behavior during enclave initialization
        • CEEBXITA behavior during enclave termination
        • CEEBXITA behavior during process termination
        • Specifying abend codes to be percolated by Language Environment
        • Actions taken for errors that occur within the exit
      • CEEBXITA assembler user exit interface
        • Guidelines for using CEEBXITA
        • Parameter values in the assembler user exit
      • CEEBINT high-level language user exit interface
    • Assembler considerations
      • Compatibility considerations
        • Control blocks
        • Save areas
        • CICS
        • C and Fortran duplicate names
      • Register conventions
        • Language Environment-conforming assembler
        • Non-Language Environment conforming assembler routines
      • Considerations for coding or running assembler routines
        • Asynchronous interrupts
        • Condition handling
        • Access to the Inbound Parameter String
        • Overlay Programs
        • CEESTART, CEEMAIN, and CEEFMAIN
        • Mode considerations
      • Language Environment library routine retention (LRR)
        • Using library routine retention
        • Library routine retention and preinitialization
        • CEELRR macro — Initialize or terminate Language Environment library routine retention
      • Assembler macros
        • CEEENTRY macro— Generate a Language Environment-conforming prolog
        • CEETERM macro — Terminate a Language Environment-conforming routine
        • CEECAA macro — Generate a CAA mapping
        • CEEDSA macro — Generate a DSA mapping
        • CEEPPA macro — Generate a PPA
        • CEELOAD macro — Dynamically load a Language Environment-conforming routine
        • CEEFETCH macro — Dynamically load a routine
        • CEEFTCH macro — Generate a FTCHINFO mapping
        • CEEGLOB macro — Extract Language Environment product information
        • CEERELES macro — Dynamically delete a routine
        • CEEPCALL macro — Call a Language Environment-conforming routine
        • CEEPDDA macro — Define a data item in the writeable static area (WSA)
        • CEEPLDA macro — Returns the address of a data item defined by CEEPDDA
        • Example of assembler main routine
        • Example of an assembler main calling an assembler subroutine
        • DSPARM subroutine example
      • Invoking callable services from assembler routines
      • System Services available to assembler routines
        • Using the ATTACH macro
          • Sharing resources
          • z/OS affinity aspects
          • Concurrency aspects
          • Termination order
          • COBOL considerations
        • Using the SVC LINK macro
    • Using preinitialization services
      • Using preinitialization
        • Using the PreInit table
          • C considerations
          • C++ considerations
          • COBOL considerations
          • Fortran considerations
          • PL/I considerations
          • Macros that generate the PreInit table
            • CEEXPIT
            • CEEXPITY
            • CEEXPITS
        • Reentrancy considerations
        • PreInit XPLINK considerations
          • Creating an XPLINK environment versus a non-XPLINK environment
        • User exit invocation
        • Stop semantics
      • Preinitialization interface
        • Initialization
          • (init_main) — initialize for main routines
            • Return codes
            • Usage notes
            • XPLINK considerations
          • (init_main_dp) — initialize for main routines (multiple environment)
            • Return codes
            • Usage notes
            • XPLINK considerations
            • Nested main_dp environment considerations
          • (init_sub) — initialize for subroutines
            • Return codes
            • Usage notes
            • XPLINK considerations
          • (init_sub_dp) — initialize for subroutine (multiple environment)
            • Return codes
            • Usage notes
            • XPLINK considerations
        • Application invocation
          • (call_main) — invocation for main routine
            • Return codes
            • Usage notes
          • (call_sub) — invocation for subroutines
            • Return codes
            • Usage notes
          • (call_sub_addr) — invocation for subroutines by address
            • Return codes
            • Usage notes
          • (end_seq) — end a sequence of calls
            • Return codes
            • Usage notes
          • (start_seq) — start a sequence of calls
            • Return codes
            • Usage notes
          • (term) — terminate environment
            • Return codes
            • Usage notes
          • (add_entry) — add an entry to the PreInit table
            • Return codes
            • Usage notes
          • (delete_entry) — delete an entry from the PreInit table
            • Return codes
            • Usage notes
          • (identify_entry) — identify an entry in the PreInit table
            • Return codes
            • Usage notes
          • (identify_environment) — identify the environment in the PreInit table
            • Return codes
          • (identify_attributes) — identify the program attributes in the PreInit table
            • Return codes
          • (set_user_word) -- set value to be used to initialize CAA user word
            • Return codes
            • Usage notes
          • (get_user_word) -- get value to be used to initialize CAA user word
            • Return codes
            • Usage notes
      • Service routines
      • An example program invocation of CEEPIPI
        • HLLPIPI examples
    • Using nested enclaves
      • Creating child enclaves
        • XPLINK considerations
        • COBOL considerations
        • PL/I considerations
      • Determining the behavior of child enclaves
        • Creating child enclaves with EXEC CICS LINK or EXEC CICS XCTL
          • How runtime options affect child enclaves
          • How conditions arising in child enclaves are handled
        • Creating child enclaves by calling a second main program
          • How runtime options affect child enclaves
          • How conditions arising in child enclaves are handled
        • Creating child enclaves using SVC LINK
          • How runtime options affect child enclaves
            • Child enclave has a C, C++, Fortran, PL/I, or Language Environment-conforming assembler main routine
            • Child enclave has a COBOL main program
          • How conditions arising in child enclaves are handled
            • Child enclave has a C, C++, or Language Environment-conforming assembler main routine
            • Child enclave has a COBOL main program
            • Child enclave has a Fortran or PL/I main routine
        • Creating child enclaves using the C system() function
          • z/OS UNIX considerations
          • How conditions arising in child enclaves are handled
          • TRAP(ON | OFF) effects for enclaves created by system()
        • Creating child enclaves containing a PL/I fetchable main
          • How runtime options affect child enclaves
          • How conditions arising in child enclaves are handled
          • Special fetch and call considerations
      • Other nested enclave considerations
        • What the enclave returns from CEE3PRM and CEE3PR2
        • Finding the return and reason code from the enclave
        • Assembler user exit
        • Message file
        • COBOL multithreading considerations
        • z/OS UNIX considerations
        • AMODE considerations
  • Prelinking an application
    • Which programs need to be prelinked
    • What the prelinker does
    • Prelinking process
      • References to currently unresolved symbols (unresolved external references)
      • Processing the prelinker automatic library call
    • Language Environment prelinker map
    • Control statement processing
      • IMPORT control statement
      • INCLUDE control statement
      • LIBRARY control statement
      • RENAME control statement
        • Usage notes
    • Mapping L-Names to S-Names
    • Starting the Prelinker under batch and TSO/E
      • Under batch
      • Under TSO/E
        • Examples
      • Using the CXXBIND EXEC under TSO/E
      • Using the CXXMOD EXEC under TSO/E
    • Prelinker options
  • EXEC DLI and CALL IMS Interfaces
  • Guidelines for writing callable services
  • Operating system and subsystem parameter list formats
    • C and C++ parameter passing considerations
      • C PLIST and EXECOPS Interactions
      • C++ PLIST and EXECOPS Interactions
      • Case sensitivity under TSO
      • Parameter passing considerations with XPLINK C and C++
    • COBOL parameter passing considerations
    • PL/I main procedure parameter passing considerations
  • Object library utility
    • Creating an object library
      • Under batch
      • Under TSO
    • Object library utility map
  • Using the systems programming environment
    • Building freestanding applications
    • Special considerations for reentrant modules
      • Notes
    • Building system exit routines
    • Building persistent C environments
    • Building user-server environments
    • Summary
  • Sort and merge considerations
    • Invoking DFSORT directly
    • Using the COBOL SORT and MERGE verbs
      • User exit considerations
      • Condition handling considerations
        • Program interrupts
        • Language Environment-signaled conditions
        • Abends
    • Using the PL/I PLISRTx interface
      • User exit considerations
      • Condition handling considerations
        • Program interrupts and Language Environment-signaled conditions
        • Abends
  • Running COBOL programs under ISPF
  • Language Environment macros
  • PL/I macros that activate variables