Bibliography. IBM Version 8.5

PL/I publications

Related publications .

DB2 UDB for OS/390 and z/OS .

TXSeries for Multiplatforms .

How to read the syntax diagrams

PL/I for AIX

Programming Guide

, SC14-7319

Language Reference

, SC14-7320

Messages and Codes

, GC14-7321

Installation Guide

, GC14-7322

Enterprise PL/I publications

Programming Guide

, GI11-9145

Language Reference

, SC14-7285

Messages and Codes

, GC14-7286

Diagnosis Guide

, GC27-1459

Compiler and Run-Time Migration Guide

, GC14-7284

Related publications

DB2 UDB for OS/390 and z/OS

Administration Guide

, SC26-9931

Command Reference

, SC26-9934

SQL Reference

, SC26-9944

Application Programming and SQL Guide

, SC26-9933

Messages and Codes

, GC26-9940

TXSeries for Multiplatforms

Encina Administration Guide Volume 2: Server Administration

, SC09-4474

Encina SFS Programming Guide

, SC09-4483

See also the Information Center: publib.boulder.ibm.com/infocenter/txformp/ v7r1/index.jsp

495

496

PL/I for Windows Programming Guide

/

Lejupielādēt

Tikai draudzīgs atgādinājums. Jūs varat apskatīt dokumentu tieši šeit. Bet pats galvenais, mūsu AI to jau ir izlasījis. Tas var izskaidrot sarežģītas lietas vienkāršiem vārdiem, atbildēt uz jūsu jautājumiem jebkurā valodā un palīdzēt ātri orientēties pat garākajos vai sarežģītākajos dokumentos.

Nē, joprojām vēlos to meklēt pats

Sveiki! Esmu AI tērzēšanas robots, kas īpaši apmācīts, lai palīdzētu jums ar Bibliography. IBM Version 8.5. Esmu rūpīgi pārskatījis dokumentu un varu palīdzēt jums atrast precīzu nepieciešamo informāciju vai izskaidrot saturu skaidri un vienkāršiem vārdiem. Neatkarīgi no tā, vai meklējat norādījumus par konkrētām funkcijām, problēmu novēršanas darbībām vai vispārēju lietošanu, droši uzdodiet savus jautājumus. Jo vairāk informācijas sniegsiet par savām bažām vai vajadzībām, jo precīzāk un efektīvāk es varu jums palīdzēt!

Palīgs raksta

Palīgs nav pie klaviatūras. Lūdzu, mēģiniet vēlreiz vēlāk.

New chat

Satura rādītājs

17

How to send your comments

19

Part 1. Introducing PL/I on your workstation

21

Chapter 1. Porting applications between platforms

23

Getting mainframe applications to compile on the workstation

23

Choosing the right compile-time options

Structure expressions

Extents of automatic variables

Using the macro facility to help port programs

Getting mainframe applications to run on the workstation

Linking differences

Data representations causing runtime differences

Environment differences affecting portability

30

Language elements causing runtime differences

31

Part 2. Compiling and linking your program

33

Chapter 2. Compiling your program

37

A short practice exercise

37

The HELLO program

37

Using compile-time options

Using the sample programs provided with the product

Preparing to compile source programs

Program file structure

Using a PROCEDURE statement with PROCESS:

Setting compile-time environment variables

Using the PLI command to invoke the compiler

44

Where to specify compile-time options

44

IBM.OPTIONS and IBM.PPxxx environment variables

Chapter 3. Compile-time options

47

Compile-time option descriptions

47

Rules for using compile-time options

Chapter 4. PL/I preprocessors

Include preprocessor options environment variable

168

Macro preprocessor

168

Macro preprocessor options

168

Macro facility options environment variables

170

SQL preprocessor

170

Programming and compilation considerations

170

SQL preprocessor options

171

SQL preprocessor options environment variable

SQL preprocessor BIND environment variables

Coding SQL statements in PL/I applications

Defining the SQL communications area

Defining SQL descriptor areas

179

Embedding SQL statements

180

Using host variables

181

Determining equivalent SQL and PL/I data types

184

Determining compatibility of SQL and PL/I data types

185

Using host structures

185

Using indicator variables

186

Host structure example

186

Using statements and compile-time options

187

Large Object (LOB) support

187

Sample programs for LOB support

187

User defined functions sample programs

188

Handling SQL error return codes

189

SQL compatibility and migration considerations

190

CICS support

190

Programming and compilation considerations

190

CICS preprocessor options

192

CICS preprocessor options environment variables

192

Coding CICS statements in PL/I applications

193

Embedding CICS statements

193

Writing CICS transactions in PL/I

193

CICS abends used for PL/I programs

194

CICS run-time user exit

194

Chapter 5. Compilation output

195

Using the compiler listing

195

Compiler output files

203

Chapter 6. Linking your program

Linking from the command line

205

Linking from a make file

Specifying directories

208

Filename defaults

208

Specifying object files

209

Using response files

209

Specifying executable output type

210

Producing an .EXE file

210

Producing a dynamic link library

210

Packing executables

211

Generating a map file

211

Linker return codes

211

Chapter 7. Setting linker options

Setting options on the command line

Setting options in the ILINK environment variable

Using the linker

Specifying numeric arguments

214

Summary of Windows linker options

214

Windows linker options

/DEFAULTLIBRARYSEARCH

/EXTDICTIONARY, /NOEXTDICTIONARY

/INFORMATION, /NOINFORMATION

220

/LINENUMBERS, /NOLINENUMBERS

Part 3. Running and debugging your program

225

Chapter 8. Using run-time options

227

Setting run-time environment variables

Specifying run-time options

227

Where to specify run-time options

227

Specifying multiple run-time options or suboptions

Shipping run-time DLLs

229

Chapter 9. Testing and debugging your programs

231

Testing your programs

231

General debugging tips

232

PL/I debugging techniques

233

Using compile-time options for debugging

233

Using footprints for debugging

234

Using dumps for debugging

235

Formatted PL/I dumps—PLIDUMP

235

SNAP dumps for trace information

239

Using error and condition handling for debugging

239

Error and condition handling terminology

239

Error handling concepts

ON-units for qualified and unqualified conditions

Conditions used for testing and debugging

Common programming errors

Logical errors in your source programs

Invalid use of PL/I

Calling uninitialized entry variables

243

Loops and other unforeseen errors

243

Tips for dealing with loops

244

Unexpected input/output data

244

Unexpected program termination

244

Other unexpected program results

245

Compiler or library subroutine failure

Part 4. Input and output

247

Chapter 10. Using data sets and files

Conventional text files and devices

250

Fixed-length data sets

250

Additional data sets

Varying-length data sets

Regional data sets

Workstation VSAM data sets

Establishing data set characteristics

Data set organizations

253

Specifying characteristics using the PL/I ENVIRONMENT attribute

Specifying characteristics using DD:ddname environment variables

CHARSET for record I/O

261

CHARSET for stream I/O

Associating a PL/I file with a data set

268

Using environment variables

268

Using the TITLE option of the OPEN statement

269

Attempting to use files not associated with data sets

270

How PL/I finds data sets

270

Opening and closing PL/I files

Associating several data sets with one file

270

Combinations of I/O statements, attributes, and options

271

DISPLAY statement input and output

273

PL/I standard files (SYSPRINT and SYSIN)

274

Redirecting standard input, output, and error devices

274

Chapter 11. Defining and using consecutive data sets

275

Printer-destined files

275

Using stream-oriented data transmission

276

Defining files using stream I/O

276

ENVIRONMENT options for stream-oriented data transmission

277

Creating a data set with stream I/O

277

Accessing a data set with stream I/O

277

Example

278

279

Controlling printed line length

282

Overriding the tab control table

284

Using SYSIN and SYSPRINT files

285

Controlling input from the terminal

285

Using files conversationally

286

Format of data

286

Stream and record files

287

Capital and lowercase letters

287

End of file

287

Controlling output to the terminal

Format of PRINT files

Stream and record files

Example of an interactive program

Using record-oriented I/O

289

Defining files using record I/O

290

ENVIRONMENT options for record-oriented data transmission

Creating a data set with record I/O

Accessing and updating a data set with record I/O

Examples of consecutive data sets

292

292

Chapter 12. Defining and using regional data sets

297

Defining files for a regional data set

299

Specifying ENVIRONMENT options

299

Essential information for creating and accessing regional data sets

299

Using keys with regional data sets

Using REGIONAL(1) data sets

Dummy records

Creating a REGIONAL(1) data set

Accessing and updating a REGIONAL(1) data set

Example

301

Chapter 13. Defining and using workstation VSAM data sets

307

Moving data between the workstation and mainframe

307

Workstation VSAM organization

307

Creating and accessing workstation VSAM data sets

308

Determining which type of workstation VSAM data set you need

308

Accessing records in workstation VSAM data sets

308

Using keys for workstation VSAM data sets

309

Using keys for workstation VSAM keyed data sets

309

Using sequential record values

310

Using relative record numbers

310

Choosing a data set type

310

Defining files for workstation VSAM data sets

312

Specifying options of the PL/I ENVIRONMENT attribute

312

Adapting existing programs for workstation VSAM

313

Adapting programs using CONSECUTIVE files

313

Adapting programs using INDEXED files

313

Adapting programs using REGIONAL(1) files

314

Adapting programs using VSAM files

314

Using workstation VSAM sequential data sets

315

Using a sequential file to access a workstation VSAM sequential data set

316

Defining and loading a workstation VSAM sequential data set

316

Updating a sequential data set

318

Workstation VSAM keyed data sets

318

Loading a workstation VSAM keyed data set

320

Using a SEQUENTIAL file to access a workstation VSAM keyed data set

322

Using a DIRECT file to access a workstation VSAM keyed data set

322

Workstation VSAM direct data sets

325

Loading a workstation VSAM direct data set

327

Using a SEQUENTIAL file to access a workstation VSAM direct data set

Using READ statements

Using WRITE statements

Using the REWRITE or DELETE statements

Using a DIRECT file to access a workstation VSAM direct data set

Part 5. Using PL/I with databases

333

Chapter 14. Open Database Connectivity

Choosing embedded SQL or ODBC

335

Using the ODBC drivers

Online help

Environment-specific information

Driver names

Configuring data sources

Connecting to a data source

337

Using a logon dialog box

337

Using a connection string

CALL interface convention

339

Using the supplied include files

339

Mapping of ODBC C types

340

Setting licensing information for ODBC Driver Manager/driver

341

Sample program using supplied include files

341

Chapter 15. Using java Dclgen

343

Understanding java Dclgen terminology

343

PL/I java Dclgen support

344

Creating a table declaration and host structure

344

Selecting a database

345

Selecting a table and generation a PL/I declaration

345

Modifying and saving the generated PL/I declaration

346

Exiting java Dclgen

347

Including data declarations in your program

347

Part 6. Advanced topics

349

Chapter 16. Using the Program Maintenance Utility, NMAKE

Using the command line

Using NMAKE command files

354

Why use a command file?

Produce error file (/X)

355

Build all targets (/A)

355

Suppress messages (/C)

355

Display modification dates (/D)

Override environment variables (/E)

Specify description file (/F)

Display help (/HELP or /?)

Ignore exit codes (/I)

Display commands (/N)

Suppress sign-on banner (/NOLOGO)

Print macro and target definitions (/P)

Return exit code (/Q)

Ignore TOOLS.INI file (/R)

Suppress command display (/S)

Change target modification dates (/T)

Targets in several description blocks

Macros in a description file

360

Macros on the command line

Special macros examples

363

File-specification parts

364

Characters that modify special macros

364

Modified special macros example

364

Macro precedence rules

Inference rules example

366

Inference-rule path specifications

366

Predefined inference rules

Predefined pseudotargets

.SUFFIXES Pseudotarget

370

.PRECIOUS Pseudotarget

Characters that modify commands

372

Turn error checking off (-)

372

Dash command modifier examples

372

Suppress command display (@)

At sign (@) command modifier example

Execute command for dependents (!)

Exclamation point (!) command modifier examples

Macros and inference rules in TOOLS.INI

EXTMAKE Syntax

374

374

TOOLS.INI example

374

Chapter 17. Improving performance

375

Selecting compile-time options for optimal performance

RETURNS(BYVALUE) or RETURNS(BYADDR)

Summary of compile-time options that improve performance

381

Coding for better performance

381

DATA-directed input and output

381

Input-only parameters

382

String assignments

382

Loop control variables

382

PACKAGEs versus nested PROCEDUREs

383

Example with nested procedures

Named constants versus static variables

385

Example with optimal code but no meaningful names

385

Avoiding calls to library routines

386

Chapter 18. Using user exits

389

Using the compiler user exit

389

Procedures performed by the compiler user exit

389

Activating the compiler user exit

390

The IBM-supplied compiler exit, IBMUEXIT

390

Customizing the compiler user exit

391

Modifying IBMUEXIT.INF

391

Writing your own compiler exit

392

Structure of global control blocks

392

Writing the initialization procedure

393

Writing the message filtering procedure

393

Writing the termination procedure

395

Using the CICS run-time user exit

395

Prior to program invocation

After program termination

Modifying CEEFXITA

Using data conversion tables

Chapter 19. Building dynamic link libraries

399

Creating DLL source files

399

Compiling your DLL source

399

Preparing to link your DLL

400

Specifying exported names under Windows

Sample program to build a DLL

401

Using FETCH and RELEASE in your main program

401

Exporting data from a DLL

402

Chapter 20. Using IBM Library Manager on Windows

403

Running ILIB

403

Using the command line

403

Using the ILIB environment variable

404

Command line

404

Windows control panel

404

Windows 98 AUTOEXEC.BAT file

405

Using an ILIB response file

405

Examples specifying ILIB parameters

405

Controlling ILIB input

406

Controlling ILIB output

406

Controlling ILIB output

407

ILIB objects

408

Summary of ILIB objects

Summary of ILIB options

Chapter 21. Calling conventions

415

Understanding linkage considerations

Tips for using OPTLINK

417

General-purpose register implications

417

Parameters

417

Examples of passing parameters

418

Passing conforming parameters to a routine

Example using SYSTEM linkage

424

STDCALL linkage (Windows only)

425

Features of STDCALL

426

Examples using the STDCALL convention

426

Using WinMain (Windows only)

Examples using the CDECL convention

429

Chapter 22. Using PL/I in mixed-language applications

431

Matching data and linkages

Maintaining your environment

435

Invoking non-PL/I routines from a PL/I MAIN

435

Invoking PL/I routines from a non-PL/I main

436

Using ON ANYCONDITION

436

Chapter 23. Interfacing with Java

439

What is the Java Native Interface (JNI)?

439

JNI Sample Program #1 - 'Hello World'

Step 1: Writing the Java Program

Declare the Native Method

Load the Native Library

Write the Java Main Method

Step 2: Compiling the Java Program

Step 3: Writing the PL/I Program

Useful PL/I Compiler Options

Correct Form of PL/I Procedure Name and Procedure Statement

JNI Include File

The Complete PL/I Procedure

Step 4: Compiling and Linking the PL/I Program

Compiling the PL/I Program

Linking the Dynamic Link Library

Step 5: Running the Sample Program

JNI Sample Program #2 - Passing a String

Step 1: Writing the Java Program

Declare the Native Method

Load the Native Library

Write the Java Main Method

Step 2: Compiling the Java Program

444

Step 3: Writing the PL/I Program

Correct Form of PL/I Procedure Name and Procedure Statement

JNI Include File

The Complete PL/I Procedure

Step 4: Compiling and Linking the PL/I Program

446

Compiling the PL/I Program

446

Linking the Dynamic Link Library

Step 5: Running the Sample Program

JNI Sample Program #3 - Passing an Integer

Step 1: Writing the Java Program

Declare the Native Method

Load the Native Library

Write the Java Main Method

Step 2: Compiling the Java Program

Step 3: Writing the PL/I Program

Correct Form of PL/I Procedure Name and Procedure Statement

JNI Include File

The Complete PL/I Procedure

Step 4: Compiling and Linking the PL/I Program

450

Compiling the PL/I Program

450

Linking the Dynamic Link Library

450

Step 5: Running the Sample Program

451

Determining equivalent Java and PL/I data types

451

Chapter 24. Using sort routines

453

Comparing S/390 and workstation sort programs

453

Preparing to use sort

454

Choosing the type of sort

455

Specifying the sorting field

457

Example:

458

Specifying the records to be sorted

458

Example:

458

Calling the sort program

Determining whether the sort was successful

459

Getting diagnostic information

460

The IBM_SORT_RC environment variable

460

The IBM_SORT_DIR environment variable

The IBM_SORT_MSGFILE environment variable

Sort data input and output

Sort data handling routines

E15 — input-handling routine (sort exit E15)

462

E35 — output-handling routine (sort exit E35)

Calling PLISRTD, example 1

469

Calling PLISRTD, example 2

471

Chapter 25. Using the SAX parser

473

Overview

473

The PLISAXA built-in subroutine

474

The PLISAXB built-in subroutine

474

The SAX event structure

standalone_declaration

475

document_type_declaration

attribute_predefined_reference

476

attribute_character_reference

476

end_of_element

476

start_of_CDATA_section

content_predefined_reference

content_character_reference

processing_instruction

comment

unknown_attribute_reference

unknown_content_reference

start_of_prefix_mapping

end_of_prefix_mapping

exception

Parameters to the event functions

Coded character sets for XML documents

479

Supported EBCDIC code pages

479

Supported ASCII code pages

480

Specifying the code page

Continuable exception codes

493

Terminating exception codes

497

Chapter 26. Using PL/I MLE in your applications

501

Applying attributes and options

501

DATE attribute

501

RESPECT compile-time option

502

WINDOW compile-time option

502

RULES compile-time option

502

Understanding date patterns

503

Patterns and windowing

503

Using built-in functions with MLE

Performing date calculations and comparisons

505

Explicit date calculations

Implicit date calculations

Implicit date comparisons

Comparing dates with like patterns

Comparing dates with differing patterns