Rational Developer for System z
Enterprise PL/I for z/OS, Version 4.1, Programming Guide

Figures

  1. Including source statements from a library
  2. Finding statement number (compiler listing example)
  3. Finding statement number (runtime message example)
  4. Using the macro preprocessor to produce a source deck
  5. The PL/I declaration of SQLCA
  6. The PL/I declaration of an SQL descriptor area
  7. Invoking a cataloged procedure
  8. Cataloged Procedure IBMZC
  9. Cataloged Procedure IBMZCB
  10. Cataloged Procedure IBMZCBG
  11. Cataloged Procedure IBMZCPL
  12. Cataloged Procedure IBMZCPLG
  13. Cataloged Procedure IBMZCPG
  14. Declaration of PLITABS
  15. PAGELENGTH and PAGESIZE
  16. Sample JCL to compile, link, and invoke the user exit
  17. Sample program to display program arguments from the CPPL under TSO when using SYSTEM(STD) option
  18. Sample program to display z/OS UNIX args and environment variables
  19. Fixed-length records
  20. How the operating system completes the DCB
  21. Creating new libraries for compiled object modules
  22. Placing a load module in an existing library
  23. Creating a library member in a PL/I program
  24. Updating a library member
  25. Creating a data set with stream-oriented data transmission
  26. Writing graphic data to a stream file
  27. Accessing a data set with stream-oriented data transmission
  28. Creating a print file via stream data transmission
  29. PL/I structure PLITABS for modifying the preset tab settings
  30. American National Standard print and card punch control characters (CTLASA)
  31. Merge Sort--creating and accessing a consecutive data set
  32. Printing record-oriented data transmission
  33. Creating a REGIONAL(1) data set
  34. Updating a REGIONAL(1) data set
  35. VSAM data sets and allowed file attributes
  36. Defining and loading an entry-sequenced data set (ESDS)
  37. Updating an ESDS
  38. Defining and loading a key-sequenced data set (KSDS)
  39. Updating a KSDS
  40. Creating a Unique Key Alternate Index Path for an ESDS
  41. Creating a Nonunique Key Alternate Index Path for an ESDS
  42. Creating a unique Key Alternate Index Path for a KSDS
  43. Alternate Index Paths and Backward Reading with an ESDS
  44. Using a Unique Alternate Index Path to Access a KSDS
  45. Defining and loading a relative-record data set (RRDS)
  46. Updating an RRDS
  47. Flow of control for Sort program
  48. Flowcharts for input and output handling subroutines
  49. Skeletal code for an input procedure
  50. Skeletal code for an output handling procedure
  51. PLISRTA--sorting from input data set to output data set
  52. PLISRTB--sorting from input handling routine to output data set
  53. PLISRTC--sorting from input data set to output handling routine
  54. PLISRTD--sorting from input handling routine to output handling routine
  55. Sorting varying-length records using input and output handling routines
  56. Simple type equivalence
  57. Sample struct type equivalence
  58. Sample enum type equivalence
  59. Start of the C declaration for its FILE type
  60. PL/I equivalent for a C file
  61. Sample code to use fopen and fread to dump a file
  62. Declarations for filedump program
  63. C declaration of fread
  64. First incorrect declaration of fread
  65. Second incorrect declaration of fread
  66. Third incorrect declaration of fread
  67. Code generated for RETURNS BYADDR
  68. Correct declaration of fread
  69. Code generated for RETURNS BYVALUE
  70. First incorrect declaration of fopen
  71. Second incorrect declaration of fopen
  72. Correct declaration of fopen
  73. Optimal, correct declaration of fopen
  74. Declaration of fclose
  75. Commands to compile and run filedump
  76. Output of running filedump
  77. Sample compare routine for C qsort function
  78. Sample code to use C qsort function
  79. Incorrect declaration of qsort
  80. Correct declaration of qsort
  81. Code when parameters are BYADDR
  82. Code when parameters are BYVALUE
  83. Java Sample Program #2 - Passing a String
  84. PL/I Sample Program #2 - Passing a String
  85. Java Sample Program #3 - Passing an Integer
  86. PL/I Sample Program #3 - Passing an Integer
  87. Java Sample Program #4 - Receiving and printing a String
  88. PL/I Sample Program #4 - Calling the Java Invocation API
  89. Sample XML document
  90. PLISAXA coding example - type declarations
  91. PLISAXA coding example - event structure
  92. PLISAXA coding example - main routine
  93. PLISAXA coding example - event routines
  94. PLISAXA coding example - program output
  95. Sample XML document
  96. PLISAXC coding example - type declarations
  97. PLISAXC coding example - event structure
  98. PLISAXC coding example - main routine
  99. PLISAXC coding example - event routines
  100. PLISAXC coding example - program output
  101. PLISAXD coding example - event routines
  102. Output from PLISAXD sample
  103. Example PL/I routine calling PLIDUMP
  104. Declare for the saved options string
  105. Using an ATTENTION ON-unit
  106. PL/I compiler user exit procedures
  107. Example of an user exit input file
  108. Record types encoded as an ordinal value
  109. Declare for the header part of a record
  110. Declare for a summary record
  111. Declare for a counter record
  112. Declare for a literal record
  113. Declare for a file record
  114. Declare for a message record
  115. Declare for an ordinal type record
  116. Declare for an ordinal element record
  117. Symbol indices assigned to the elements of a structure
  118. Data type of a variable
  119. Declare for a symbol record
  120. Declare for xin_Bif_Kind
  121. Declare for a source record
  122. Declare for a token record
  123. Declare for the token record kind
  124. Node indices assigned to the blocks in a program
  125. Declare for a syntax record
  126. Declare for the syntax record kind
  127. Node indices assigned to the syntax records in a program
  128. Declare for the expression kind
  129. Declare for the number kind
  130. Declare for the lexeme kind
  131. Declare for the voc kind

Terms of use | Feedback

This information center is powered by Eclipse technology. (http://www.eclipse.org)