Skip to main content

Full text of "ibm :: 360 :: fortran :: SC28-6852-1 OS FORTRAN H Pgmr Jun72"

See other formats


SC28-6852-1 



Program Product 



IBM OS FORTRAN IV 
(H Extended) Compiler 
Programmer's Guide 



Program Numbers: 5734-F03 
5734-LM3 



This publication describes the steps to compile, link edit, 
and execute a FORTRAN IV program using the 
FORTRAN IV (H Extended) compiler, an IBM Program 
Product that operates under the control of the operating 
system. The methods of invoking each step, input to the 
steps, and output from the steps, are detailed. In addition, 
compiler options, features of the operating system used 
by the FORTRAN programmer, and practices for coding 
more efficient FORTRAN programs are discussed. 



This publication is directed to programmers familiar with 
the FORTRAN IV language. Previous knowledge of the 
operating system is not required. 



Information in this publciation pertaining to OS/VS2 is 
for planning purposes until that product is available. 





JL 


a 




Second Edition (June 1972) 

This edition corresponds to Release 1 of the FORTRAN IV (H Extended) 
Compiler. 

Changes are periodically made to the specifications herein; any such 
changes will be reported in subsequent revisions or Technical 
Newsletters. 

Requests for copies of IBM publications should be made to your IBM 
representative or to the IBM branch office serving your locality. 

A form for readers' comments is provided at the back of this 
publication. If the form has been removed, comments may be addressed to 
IBM Corporation, Programming Publications, 1271 Avenue of the Americas, 
New York, New York 10020. 

© Copyright International Business Machines Corporation 1971 



Summary of Amendments Number 1 



Date of Publication: June, 1972 

Form of Publication: Revision, SC28-6852-1 



OS/VS Information Added 

New: Programming and Documentation 

The use of the FORTRAN IV (H Extended) compiler with OS/VS 1 and OS/VS2 is described. A 
brief overview of the virtual storage concept has been added to the Introduction, and the section 
"Using Job Control Statements" has been updated to include descriptions of the VS REGION and 
ADDRSPC parameters of the JOB and EXEC statements and the VS COPIES, DLM, and SYSOUT 
parameters of the DD statement. The ORDER and PAGE control statements of the linkage editor 
are discussed in the "Linkage Editor and Loader" section. In addition, publication references 
throughout the text have been revised to include the appropriate OS/VS publications. 



ERRSET Description Expanded 

Maintenance: Documentation Only 

The description of the inomes option of the ERRSET subroutine of the Extended Error Handling 

Facility has been expanded to explain how an unlimited number of error messages may be printed. 

Compiler System Requirements Information Removed 

Maintenance: Documentation Only 

Information about the system requirements of the FORTRAN IV (H Extended) compiler has been 
removed from the "Programming Considerations" section. This information can be found in the 
publication OS FORTRAN IV (H Extended) Installation Reference Material, Order No. SC28-6861. 

Descriptions of SPLIT and SUBALLOC Removed 

Maintenance: Documentation Only 

Information pertaining to the SPLIT and SUBALLOC parameters of the DD statement has been 
removed from the section "Using Job Control Statements." Detailed descriptions of these 
parameters can be found in the job control language reference publications listed in the Preface. 



System/360 Dependence of Some Direct Access Units Noted 

Maintenance: Documentation Only 

The use of the 2303, 2311, and 2321 direct access units with System/360 machines only is 

indicated in Appendix C: Unit Types. 

Description of XCAL Removed 

Maintenance: Documentation Only 

Information pertaining to the XCAL option of the linkage editor has been removed from the 
section "Linkage Editor and Loader." A detailed description of this option can be found in 
the linkage editor and loader publications listed in the Preface. 



Asynchronous I/O Information Expanded 

Maintenance: Documentation Only 

Added information includes the fact that blocked records may not be used with asynchronous I/O, 
that a BUFNO specification of three buffers in a DCB parameter is limited to asynchronous I/O 
only, and that a user-exit routine cannot perform any asynchronous I/O operation, even if the 
error involved was not caused during asynchronous I/O processing. 



SIZE Option Information Expanded 

Maintenance: Documentation Only 

The use of the SIZE option of the PARM parameter of the JOB or EXEC statements to reduce the 
amount of storage required by the compiler in a multitasking environment is explained. The 
restriction that SIZE may not be specified on a *PROCESS card is noted. 

OPTIMIZED) Information Expanded 

Maintenance: Documentation Only 

The explanation of computational reordering results under OPTIMIZER) in the section 

"Programming Considerations" is expanded. 



Editorial changes having no technical significance are not noted here. 

Specific changes to the text as of this publishing date are indicated by a vertical bar to the left of the text. 

These bars will be deleted at any subsequent republication of the page affected. 



PREFACE 



This publication describes the use of the 
operating system and the FORTRAN IV (H 
Extended) compiler to process programs 
written in the FORTRAN IV language. The 
FORTRAN IV language is described in the 
publication I BM System/360 and Sy s tem/370: 
FORTRAN IV Language , Order No. GC28-6515. 



This publication is designed for FORTRAN 
users having various programming needs. 
The programmer who wants to process a 
FORTRAN program using the compiler and 
wants to interpret the output should read 
the introduction and the first section "How 
to Submit a FORTRAN Program" in "Part 
I — Job Input. " The introduction explains 
system concepts to help the programmer 
understand how the compiler and other 
operating system resources process a 
FORTRAN program and also describes the 
forms of program output. The section "How 
to Submit a FORTRAN Program" describes in 
greater detail how a program is processed 
under control of the operating system. 

The remainder of the publication is 
directed to programmers who required 
detailed reference material regarding the 
operation of the compiler and its 
facilities. 



• Part III — Programmin g Te chniques . Part 
III deals with program efficiency. The 
first section describes programming 
considerations for designing and coding 
more efficient FORTRAN programs. The 
remaining sections describe such 
facilities as the compiler automatic 
precision increase (API) facility, the 
linkage editor overlay feature, and the 



iu iiiwu u j-c: 



facility. 



Appendixes . The appendixes describe 
sample FORTRAN programs; the use of 
assembler language subprograms; the 
input/output units available with 
System/360 and System/ 370; and the 
carriage control characters available 
to the FORTRAN programmer. 



The FORTRAN programmer using the FORTRAN 
IV (H Extended) compiler and the FORTRAN IV 
library (Mod II) should be familiar with 
the information in the following 
publications : 

IBM System/360 and System/370 
FORTRAN IV Language 
Order No. GC28-6515 



The publication is organized as follows: 

• Introduction . The introduction 
provides an overview of the operating 

c?\/<5i-#3Tri ar\r\ how i +■ interaf^c With the 

compiler during the processing of a 
FORTRAN program. Job control language, 
cataloged procedures, data sets and 
libraries, and program output are 
described. The information contained 
in the introduction is covered in 
greater detail in subsequent sections. 

• Part I — Job Input . Part I describes 
how a FORTRAN program is processed 
under control of the operating system. 
The first section summarizes how a 
FORTRAN program may be submitted for 
processing. The remaining sections 
describe job control language; the 
three steps in processing a FORTRAN 
program (compiling, link editing, and 
executing a load module) ; and 
IBM-supplied cataloged procedures. 

• Part II — Job Output . Part II describes 
the output from each step in FORTRAN 
processing and includes examples of 
both operating system and FORTRAN 
program output. 



OS F ORTRAN IV Library 

Mathematical and Service Subprograms 

Order No. GC28-6818 



OC rnDTDAH T\1 M 3 4-hp 






Subprograms 

Supplement for Mod I and Mod II 

Librari es 

Order No. SC28-6864 

OS FORTRAN IV (H Extended) Compiler 

and FORTRAN IV Library (Mod II) Messages 

Order No. SC28-6865 

Information about the job control 
language can be found in the following 
publications : 

O S/MFT and OS/MVT Job Control Languag e 
R eference , Order No. GC28-6704 

OS/VS Job Control Language Reference, 
Order No. GC28-0618 

Information about IBM-supplied utility 
programs can be found in the following 
publications : 

O S/MFT and OS/MVT Utilities . Order 
No. GC28-6586 



O S/VS Utilities , Order No. GC35-0005 



Information about the linkage editor and 
loader programs can be found in the 
following publications : 



O S/MFT and OS/MVT Linkage Editor and 
Loader , Order No. GC28-6538 



O S/VS Linkage E dito r and Loade r, Order 
NO. GC26-3813 



Information about debugging techniques 
can be found in the following publications: 



O S/MFT a nd OS/MVT Programmer's Guide to 
D ebugging , Order no. GC28-6670 



S/VS1 Debugging Guide , Order 
No. GC2U-5093 



OS/VS 2 Debugging Guide , Order 
No. GC28-0632 



Information about assembler language 
programming can be found in the following 
publications: 



OS/MFT and OS/MVT Assembler Language , 
Order No. GC28-6514 



O S/VS Assembler Language , Order 
No. GC33-4010 



QS/MFT and OS/MVT Assembler Programmer's 
Guide, Order No. GC 2 6- 3756 



O S/VS Assembler Programmer' s Guide , 
Order No. GC33-4021 



Information about System/360 and 
System/370 machine characteristics can be 
found in the following publications : 



IBM System/360 Principles of Operation , 
Order No. GA22-6821 



I BM System/370 Principles of Operation , 
Order No. GA22-7000 



CONTENTS 



INTRODUCTION 11 

Control Program 11 

Processing Programs ....11 

Problem Programs 12 

Processing A Fortran Program ...... 12 

Job Control Language Statements ... 12 

Compile Only (One Source Module) . . 13 
Compile Only (More Than One Source 

Module) 13 

Compile and Link Edit 13 

Compilej Link Edit, and Execute s s 13 

Cataloged Procedures ... 13 

Data Sets 14 

System Data Sets 14 

Compiler Data Sets 14 

Linkage Editor Data Sets .14 

Load Module Execution Data Sets . . 14 

Loader Data Sets 15 

User Data Sets 15 

Cataloged Data Sets ......... 15 

Libraries of Data Sets 15 

System Libraries 16 

User Libraries 16 

Program Output 16 

PART I — JOB INPUT 17 

SUBMITTING A FORTRAN PROGRAM 19 

Defining Private Data Sets 21 

USING JOB CONTROL STATEMENTS 22 

Syntax For Parameter Description .... 23 

JOB Statement 24 

Naming the Job 25 

Specifying Accounting Information . 25 

Specifying the Programmer's Name . . 27 

Specifying System Messages 27 

Specifying Condition Codes to 

Terminate a Job 27 

Assigning Job Priority 28 

Assigning an Output Writer 28 

Assigning a Time Limit to a Job . . 28 
Assigning Storage to a Job Under 

MVT 29 

Assigning Storage to a Job Under VS 29 

EXEC Statement 30 

Naming an EXEC Statement 32 

Naming the Cataloged Procedure or 

Program to be Executed .32 

Specifying Program Options 34 

Specifying Accounting Information . 35 
Specifying Condition Codes to 

Bypass a Job Step ...35 

Assigning Step Priority 35 

Assigning a Time Limit to a Job 

Step 36 

Assigning Storage to a Job Step 

Under MVT 36 

Assigning Storage to a Job Step 

Under VS 36 

DD Statement . 37 

DD Statement Uses 41 



Naming a DD Statement 42 

Data Set Location 42 

Data Set Identification ...... 43 

Data Set Disposition 4 4 

Assigning a Data Set to an 

Input/Output Device 46 

Assigning Space to a Data Set on a 

Direct Access Volume 47 

Data Set Labels 47 

Assigning Channel Use 48 

Defining Record Characteristics ;. ^ 49 

COMPILATION 53 

Compiler Options ..... 53 

Changing Program Options During a 

Batch Compilation . 55 

Compiler Data Sets 55 

Data Sets Defined in Cataloged 

Procedures 55 

Data Sets That Must Be Defined b" 

the Programmer 56 

LINKAGE EDITOR AND LOADER 58 

Choosing the Proper Linkage Program . . 58 

Link Edit Job Step 58 

Linkage Editor Options 58 

Linkage Editor Data Sets 59 

Data Sets Defined in Cataloged 

Procedures ...... 59 

Data Sets That Must Be Defined by 

the Programmer ......60 

Primary Input .60 

Secondary Input 61 

Linkage Editor Control Statements . 61 
Ordering and Page-Aligning Program 

Units Under OS/VS . 62 

System Loader 63 

Loader Options 63 

Loader Data Sets 65 

Data Sets Defined in Cataloged 

Procedures 65 

Data Sets That Must be Defined by 

the Programmer ......66 

LOAD MODULE EXECUTION 67 

Load Module Data Sets ........ 67 

Data Sets Defined in Cataloged 

Procedures 67 

Data Sets That Must Be Defined by 

the Programmer 68 

Sequential Data Sets 68 

Partitioned Data Sets 70 

Retrieving More Than One Member . . "?0 

Deleting One Member 71 

Direct-Access Data Sets 71 

DCB Parameter Considerations 71 

DCB Considerations for Sequential 

EBCDIC Data Sets 73 

DCB Considerations for ASCII Data 

Sets 76 

DCB Considerations for 

Direct-access Data Sets ...... 80 



IBM- SUPPLIED CATALOGED PROCEDURES ... 81 

Cataloged Procedure Restrictions .... 81 

FORTRAN PROCESSING Cataloged Procedures 81 
Symbolic Parameters and the PROC 

Statement .....88 

Compiling 89 

Link Editing 89 

Executing the Load Module 90 

Loading 90 

Modifying Cataloged Procedures 90 

Modifying PROC Statements 90 

Modifying EXEC Statements 91 

Modifying DD Statements • 91 

PART II — JOB OUTPUT 95 

JOB OUTPUT 97 

COMPILER OUTPUT 99 

Compiler Output With Default Options • 99 

Informative Messages 99 

Diagnostic Messages . 101 

Source Listing 101 

Compiler Output With 

Programmer-Specified Options 101 

Cross-Ref erence Listing 101 

Object Module Listing . 104 

Edited Source Module Listing . . . .105 

Source Module Map 105 

Object Module Deck 106 

LINKAGE EDITOR AND LOADER OUTPUT . . . .108 
Linkage Editor Output 108 

Linkage Editor Output With 

Procedure-Specified Options . • . . .108 

Cross-Ref erence Table 108 

Loader Output 110 

LOAD MODULE OUTPUT Ill 

Messages Ill 

Error Code Diagnostic Messages .... Ill 
Using the Traceback Map 112 

Program Interrupt Messages 113 

Requesting a Dump 115 

Operator Messages 115 

Program Output 116 

PART III — PROGRAMMING TECHNIQUES . . . 119 

PROGRAMMING CONSIDERATIONS 121 

FORTRAN Implementation 121 

Array Considerations 121 

Arithmetic IF Statement 121 

Asynchronous Input/Output Programming 

Considerations 121 

BACKSPACE Statement 122 

COMMON and EQUIVALENCE Statements 

Used Together .122 

COMMON Statement 122 

Data Initialization Statement — 

Specifying Literals 123 

Direct-Access Input/Output 

Considerations 124 

EQUIVALENCE Statement 12 5 

EXTERNAL Statement 126 

GENERIC Statement 126 



Input/Output Statements — 

Unformatted Forms . .127 

List-Directed Input/Output 127 

Logical IF Statement 127 

Name Handling 127 

OPTIMIZE Compiler Option 127 

READ Statement 129 

RETURN Statement 129 

STOP Statement 129 

User-Supplied Subroutines 129 

Job Control Language Considerations . .129 
Using Pre-allocated Data Sets .... 130 

FORTRAN Library Considerations 130 

DUMP and PDUMP Subprograms 130 

Extended-Precision Subroutines .... 131 

Sense Light Subprograms 131 

System Considerations 131 

Compilation Considerations 131 

Compiler Storage Requirements . . . 131 

Compiler Restrictions 132 

Load Module Considerations 133 

Load Module Restrictions 133 

Boundary Alignment Considerations .133 

Using Names Recognized by the 

Compiler as Generic or an Alias . . 133 

AUTOMATIC PRECISION INCREASE FACILITY .134 

The Conversion Process 134 

Promotion 134 

EXEC Statement Options . 135 

AUTODBL Subparameter 135 

Coding Examples ..... 138 

ALC Subparameter 138 

Programming Considerations With API . 138 
Effect on COMMON or EQUIVALENCE 

Data Values 13 M 

Effect on Literal Constants .... 139% 
Effect on Programs Calling 

Subprograms 139 

Effect on FORTRAN Library 

Subprograms . 139 

Effect on CALL DUMP or CALL PDUMP 

Statements 139 

Effect on Direct-Access 

Input/Output Processing 140 

Effect on Asynchronous Input/Output 

Processing 140 

Effect on Unformatted Input/Output 

Data Sets 140 

Effect on the Storage Map ..... 140 

LINKAGE EDITOR OVERLAY FEATURE 141 

Designing a Program for Overlay .... 141 
Segments ............... 141 

Paths 142 

Communicating Between Segments .... 143 

Inclusive References 143 

Exclusive References . 144 

COMMON Areas 144 

The OVERLAY Process 144 

Construction of the OVERLAY Program . .146 
Linkage Editor Control Statements . .146 

OVERLAY Statement ..146 

INSERT Statement 146 

INCLUDE Statement 147 

ENTRY Statement 148 

Linkage Editor OVERLAY Options . . . .148^ 
Overlay Example 14« 



EXTENDED ERROR HANDLING FACILITY . . . .154 

Functional Characteristics 154 

Subprograms for the Extended Error 
Handling Facility ........... Ibo 

ERRSAV Subroutine . .156 

ERRSTR Subroutine 156 

ERRSET Subroutine 158 

ERRTRA Subroutine 160 

User-Supplied Error Handling 160 

User-Supplied Exit Routine 161 

Option Table considerations 163 

Considerations for the Library 

Without Extended Error Handling 

Facility 163 

APPENDIXES 171 

APPENDIX A: EXAMPLES OF JOB PROCESSING .17 3 

APPENDIX B: ASSEMBLER LANGUAGE 

SUBPROGRAMS 179 

Subroutine References 179 

Argument List 179 

Save Area 179 

Calling Sequence 179 

Coding the Assembler Language 

Subprogram ....... .181 



Coding a Lowest Level Assembler 

Language Subprogram 181 

Higher Level Assembler Language 

Subprogram 181 

In-Line Argument List 183 

Sharing Data in COMMON 183 

Retrieving Arguments From the Argument 

List 183 

RETURN i in an Assembler Language 

Subprogram . .....184 

Object-Time Representation of FORTRAN 

Variables 184 

INTEGER Type 185 

REAL Type 186 

COMPLEX Type 187 

LOGICAL Type 188 

APPENDIX C: UNIT TYPES 189 

Tape Units 189 

Direct Access Units 189 

Unit Record Equipment 189 

Graphic Units 189 

APPENDIX D: AMERICAN NATIONAL STANDARD 
CARRIAGE CONTROL CHARACTERS 190 

INDEX 191 



FIGURES 



Figure 1-1. Submitting FORTRAN 

Programs Through Cataloged Procedures . 19 

Figure 1-2. Job Control Statement 

Formats ................22 

Figure 1-3. Job Statement Format ... 25 
Figure 1-4. Sample JOB Statements ... 25 
Figure 1-5. EXEC Statement Format . . 30 
Figure 1-6. Sample EXEC Statements . . 32 
Figure 1-7. DD Statement Format .... 37 

Figure 1-8. Sample DD Statements ... 38 
Figure 1-9. compiler Options ..... 56 

Figure 1-10. Linkage Editor Options . . 58 
Figure 1-10.1. Ordering and Aligning 
Program Units on Page Boundaries ... 63 
Figure 1-11. Linkage Editor 

Processing 64 

Figure 1-12. Loader Options 65 

Figure 1-13. Defining Unit Record - 

Data Sets 69 

Figure 1-14. Creating EBCDIC 
Sequential Data Sets on Tape or Direct 

Access Volumes .69 

Figure 1-15. Retrieving Sequential 

Data Sets 69 

Figure 1-16. Creating an ASCII Tape 

Data Set 69 

Figure 1-17. Creating Partitioned 

Data Sets 70 

Figure 1-18. Retrieving Partitioned 

Data Sets 70 

Figure 1-19. Deleting a Member of a 

Partitioned Data Set 72 

Figure 1-20. Creating a Direct-Access 

Data Set 72 

Figure 1-21. Retreiving a 

Direct- Access Data Set 72 

Figure 1-22. EBCDIC Sequential Data 

Sets — Structure of Formatted Records . . 75 

Figure 1-23. EBCDIC Sequential Data 

Sets — Structure of Unformatted Records . 76 

Figure 1-24. ASCII Data Sets — 

Structure of Records 78 

Figure 1-25. Direct-Access Data 

Sets — Structure of Records 80 

Figure 1-26. Cataloged Procedure 

FORTXC 8 2 

Figure 1-27. Cataloged Procedure 

FORTXCL 8 3 

Figure 1-28. Cataloged Procedure 

FORTXLG 8 4 

Figure 1-29. Cataloged Procedure 

FORTXCLG 8 5 

Figure 1-30. Cataloged Procedure 

FORTXG 8 6 

Figure 1-31. Cataloged Procedure 

FORTXCG 87 

Figure 1-32. Cataloged Procedure 

FORTXL 8 8 

Figure 1-33. PROC Statement Format . . 88 

Figure 1-34. Effect of PROC Statement 

in a Cataloged Procedure 89 



Figure 1-35. Submitting Modifications 

to a Cataloged Procedure 93 

Figure II-l. Sample Program as Coded . 97 
Figure II-2. Sample Program as 

Keypunched 98 

Figure II-3. Compiler Printed Output 

Format 99 

Figure I I- 4. Compiler Output from 

Default Options 100 

Figure II-5. Compiler Output from 

Programmer-Specified Options 102 

Figure II- 6. Object Module Deck 

Structure 107 

Figure II-7. Source Statements and 
Storage Map for COMMON/EQUIVALENCE 

Blocks 107 

Figure II-8. Linkage Editor Output 

From Procedure-Specified Options .... 109 

Figure II-9. Loader Output . 110 

Figure 11-10. Load Module Output with 

Traceback Map 112 

Figure 11-11. Partial Object Code 

Listing 114 

Figure 11-12. Comparison of FORTRAN 
Statement as Coded and as Keypunched . 114 
Figure 11-13. Program Interrupt 

Message Format 116 

Figure 11-14. Operator Message Format 116 

Figure 11-15. Program Output 117 

Figure III-l. Record Chaining . . . .125 
Figure III-2. Writing a Direct-Access 

Data Set for the First Time 126 

Figure III-3. Storage Structure Using 

SIZE and REGION 132 

Figure III-4. A FORTRAN Program 

Containing Three Program Units 141 

Figure III-5. Time/Storage Map of 
Program Described in Figure III-4 . . . 141 
Figure III-6. Overlay Tree Structure of 
Program Described in Figure III-4 . . . 142 
Figure III-7. Overlay Paths Implied by 

Tree Structure in Figure III-6 142 

Figure III-8. Overlay Tree Structure 

Having Six Segments 143 

Figure III-9. Overlay Paths Implied 
by Tree Structure in Figure III-8 . . . 143 
Figure 111-10. Overlay Configuration of 
Program Described in Figure III-8 . . .144 
Figure III- 11. Communication Between 

Overlay Segment 144 

Figure 111-12. Overlay Program Before 
Automatic Promotion of Common Areas . .145 
Figure 111-13. Overlay Program After 
Automatic Promotion of Common Areas . . 145 
Figure 111-14. Linkage Editor Overlay 

Input 150 

Figure 111-15. Linkage Editor Overlay 

Output — Compile Job Step 151 

Figure 111-16. Link Edit Overlay 

Output — Link Edit Job Step 152 



Figure 111-17. Linkage Editor Overlay 
Output — Load Module Execution Job 

Step 153 

Figure 111-18. Sample Program Using 
the Extended Error Handling Facility .162 
Figure 111-19. Option Table Preface s s 164 
Figure 111-20. Option Table Entry . . .165 
Figure A-l. Input/Output Flow for 

Example 1 173 

Figure A- 2. Job Control statements 

for Example 1 174 

Figure A-3. Input Flow for Example 2 

174 

Figure A-4. Job Control Statements 

for Example 2 175 



Figure A-5. Block Diagram for Example 

3 176 

Figure A-6. FORTRAN Coding for 

Example 3 178 

Figure A-7. Job Control Statements 

for Example 3 178 

Figure A- 8. Save Area Layout and Word 

Contents 180 

Figure A- 9. Linkage Conventions for 

Lowest Level Subprogram 181 

Figure A-10. Linkage Conventions for 

Higher Level Subprogram 182 

Figure A-ll. In-Line Argument List . . 183 

Figure A-12. Assembler Subprogram 

Example 185 



TABLES 



Table 1-1. Job Control Statement 

Functions .......... 22 

Table 1-2. JOB Statement Functions . . 26 

Table 1-3. EXEC Statement Functions . . 31 

Table 1-4. DD Statement Functions ... 39 

Table 1-5. Data Set Names 44 

Table 1-6. Device Class Names 46 

Table 1-7. Compiler Data Sets 57 

Table 1-8. DCB Default Values for 

Compiler Data Sets 57 

Table 1-9. Linkage Editor Data Sets . . 60 

Table 1-10. Loader Data Sets. ..... 66 

Table 1-11. Load Module Data Sets ... 68 
Table 1-12. DCB Default Values for 

Load Module Data Sets ....72 

Table 1-13. Maximum BLKSIZE Values . . 73 



Table III-l. Built-in Functions — 
Substitution of Single and Double 

Precision ..... 136 

Table III-2. Library Functions — 
Substitution of Single and Double 

Precision 136 

Table III- 3. Option Table Default 

Values 155 

Table III-4. Corrective Action After 

Error Occurrence 157 

Table III-5. Corrective Action After 
Mathematical Subroutine Error 

Occurrence 166 

Table III-6. Corrective Action After 

Program Interrupt Occurrence 170 

Table A-l. Linkage Registers ..... 180 

Table A-2., Dimension and Subscript 

Format 184 



INTRODUCTION 



A program written for the FORTRAN IV 
(H Extended) compiler is processed under 
control of the IBM System/360 Operating 
System. The compiler is a program product 
included as part of the operating system in 
a process called program installation . The 
operating system consists of a control 
program and a number of processing programs 
that perform operations on problem 
p rograms . 



CONTROL PROGRAM 



The control program supervises the 
execution of the operating system and 
provides services reguired by all other 
programs. One of four control programs may 
be specified for use with the FORTRAN IV 
(H Extended) compiler: Multiprogramming 
with a Fixed Number of Tasks ( MFT ) , 
Multiprogramming w ith a Variable Numbe r of 
Task s (MVT), and the virtual storage 
control programs VS1 and VS2. Each control 
program may handle up to 15 concurrently 
operating programs, and each control 
program has these major functions: 

1. The supervisor is the control center 
of the operating system and 
coordinates all activity within it. 

2. The job scheduler reads and analyzes 
the input job stream (control 
statements and data entering the 
system) , allocates input/output 
devices as necessary, initiates the 
execution of programs, and provides a 
record of the work processed. 

3. Data manageme nt routines control 
input/output operations, regulate the 
use of input/output devices after the 
job scheduler allocates them, and 
provide access to the data held in 
them. 

The MFT and VS1 control programs divide 
computer storage into areas of fixed sizes 
called partitions . Data entering the 
system is directed to these partitions on a 
priority scheduling basis; that is, data is 
not processed in the order in which it is 
encountered in the input stream but 
according to a priority code assigned by 
the user. 

The MVT and VS2 control programs, like 
MFT and VSl, process data on a priority 
scheduling basis, but direct it to storage 



areas of variable sizes, called regions ; 
each user indicates the amount of storage 
he needs. 

VSl is the virtual storage version of 
MFT, and VS2 is the virtual storage version 
of MVT. Both VS control programs provide 
the same services as their non-relocatable 
counterparts, but the partitions (VSl) and 
regions (VS2) to which job steps are 
directed are represented in virtual, rather 
than real, storage. Virtual storage is the 
name given to the address space that 
appears to the user as real (main) storage 
and from which instructions and data are 
mapped into real storage locations. The 
size of virtual storage is limited by the 
addressing range of the computing system, 
not the number of real storage locations. 
(Under OS/VS the term rea l storage is used 
to designate the physical main storage of 
System/370 rather than its complete 
addressing range. ) 

Virtual storage is provided by space on 
direct access storage devices (DASDs) and 
implemented by a combination of the Dynamic 
Address Translation (DAT) hardware feature 
of System/370 (often called the "relocate" 
feature) and the p agin g function provided 
by the OS/VS control programs. The 
contents of virtual storage are formatted 
into 2048 byte blocks (VSl) or 4096 byte 
blocks (VS2). These blocks are called 
pages. During execution of a program, the 
hardware system translates each virtual 
storage address into a corresponding real 
storage address that designates a physical 
location. The translation process actually 
amounts to relocation by a value that is a 
multiple of one page. The VS control 
program manages the transfer of pages 
between auxiliary storage and real storage. 
The number of pages that may reside in real 
storage at any given time depends on the 
amount of real storage available. The VS 
control programs enable the central 
processing unit to execute programs 
residing in virtual storage without moving 
all of the pages into real storage 
concurrently. 



PROCESSING PROGRAMS 



Processing programs perform specific tasks, 
such as language translation, link editing, 
loading, sorting and merging, and various 
utility functions. Language trans lators, 
or compilers , include FORTRAN, COBOL, and 



Introduction 11 



PL/ I. The linkage ed ito r and the loader 
programs combine many programs into one 
executable unit. Sort and merge programs 
sequence data into ordered formats prior to 
further processing. Utility programs 
provide the ability to create, print, 
duplicate, and reformat collections of 
data. 



execution followed by linkage editor 
execution and load module execution. 



The programmer defines the requirements 
of each job to the operating system through 
job control langu age statements . 



Processing programs of special concern 
to the FORTRAN programmer are the FORTRAN 
IV (H Extended) compiler, which translates 
FORTRAN statements into executable 
instructions; the linkage editor, which 
combines the FORTRAN program with 
subroutines from the FORTRAN library or 
user libraries with other routines required 
by the system; and the loader, which 
combines a number of programs and 
subprograms as does the linkage editor and 
then executes the resulting program. 



PROBLEM PROGRAMS 



Problem programs are written by the user 
for the creation and maintenance of files, 
creation of reports, solution of problems, 
or for whatever use the user wishes to make 
of the computer (for instance, a FORTRAN 
program, designed to do some particular 
work). Before it can do its work, however, 
the FORTRAN program must be processed by 
the operating system. 



PROCESSING A FORTRAN PROGRAM 



Three basic steps are taken to process a 
FORTRAN program: the compile step, the 
link edit step, and the load module 
execution (or go) step. The input to the 
compile step is the group of FORTRAN 
statements called a source module . The 
output from the compile step is a group of 
compiler-translated statements called an 
object module, which is the input to the 
link edit step. The output of the link 
edit step is the object module combined 
with other modules and is called the load 
module , the program that is executed in the 
go step. If the loader is used in place of 
the linkage editor, the last two steps 
(link edit and load module execution) are 
combined into one step. 

Each step is termed a job step — the 
execution of one program. Each job step 
may be executed alone or in combination 
with other job steps as a job — an 
application involving one or more job 
steps. Hence, a job may consist of one 
step, such as FORTRAN compiler execution, 
or of many steps, such as compiler 



JOB CONTROL LANGUAGE STATEMENTS 



A job control language statement is 
identified by the appearance of the 
characters // or /* in the statement's 
first two positions. The job control 
statements most often used by FORTRAN IV 
programmers are the JOB, EXEC, DD, 
delimiter, and null statements. 

The JOB statement identifies the 
beginning of a job. It is required for 
each job, must be the first statement in a 
job, and must have a name to identify the 
job. It may also contain other information 
such as the programmer's name, accounting 
information, certain system options, and 
comments. 

The EXEC statement identifies the 
beginning of a job step. It is required 
for each job step and must be the first 
statement in the step. The EXEC statement 
may be named to identify the step. The 
statement must specify the name of the 
program to be executed. It may also 
contain other information such as processor 
options and comments. 

The DD statement defines a data set. A 
data set is an organized collection of 
records such as a source program, a set of 
input records, or a library of subprograms. 
The DD statement specifies information 
regarding a data set's characteristics, its 
location, its name, format of records 
contained in the data set, and the 
disposition to be made of the data set at 
the end of the job step. 

The delimiter statement contains the 
characters /* in the first two positions 
and indicates the end of a data set 
contained on cards. 

The null statement contains the 
characters // in the first two positions 
and indicates the end of the job. The 
remainder of the card must be blank. 

The following examples illustrate the 
positioning of job control statements, 
within a job for some of the combinations 
of FORTRAN processing. 



12 



Compile Only (One Source Module) 



Compi le, Link Edit, and Execute 



// JOB Statement 

// EXEC Statement (to execute FORTRAN 

compXj.ei i 
// DD Statements for compilation (as 

required) 

r 1 

| Source module to be compiled | 

i j 

/* Delimiter Statement (if source module is 

on cards) 
// Null Statement 



Compile Only (More Than One Source Module) 



// JOB Statement 

// EXEC Statement (FORTRAN compiler) 
// DD Statements for compilation 1 (as 
required) 



j Source module to be compiled! 

L : J 

/* Delimiter Statement (if source module is 

on cards) 
// EXEC Statement (FORTRAN compiler) 
// DD Statements for compilation 2 (as 

required) 

r 1 

| Source module to be compiled | 
i j 

/* Delimiter Statement (if source module is 

on cards) 
// EXEC statement (FORTRAN compiler) 
// DD Statements for compilation 3 (as 

required) 



r 1 

}Source module to be compiled j 
l J 

/* Delimiter Statement (if source module is 

on cards) 
// Null Statement 



Compile and Link Edit 



// JOB Statement 

// EXEC Statement (FORTRAN compiler) 
// DD Statements for compilation (as 
required) 

r 1 

| Source module to be compiled| 
l J 

/* Delimiter Statement (if source module is 

on cards) 
// EXEC Statement (Linkaqe Editor) 
// DD Statements for link editing (as 

required) 
// Null Statement 



// JOB Statement 

// EXEC Statement (FORTRAN compiler) 
// DD Statements for compilation (as 
required) 

r 1 

| Source module to be compiled | 

L j 

/* Delimiter Statement (if source module is 

on cards) 
// EXEC Statement (Linkage Editor) 
// DD Statements for link editing (as 

required) 
// EXEC Statement (Load Module) 
// DD Statements for load module execution 

(as required) 

r -i 

| Data input statements to be processed | 

l j 

/* Delimiter Statement (if data input is on 

cards) 
// Null Statement 



As these examples show, the same job 
control statements are used repeatedly. To 
save programming time and to reduce the 
possibility of error, IBM supplies sets of 
job control statements that the programmer 
may use in place of his own. Each set is 
given a name and is stored in a data set 
called the procedure library . The sets of 
statements are called cataloged proc edures* 



CATALOGED PROCEDURES 



To retrieve a cataloged procedure from the 
library, the programmer specifies its name 
in an EXEC statement in place of a program 
name. The effect is the same as though the 
job control statements in the cataloged 
procedure appeared in the input stream in 
place of the EXEC statement that called it. 

Note that a cataloged procedure does not 
execute a program; it merely supplies a set 
of job control statements. These 
statements must include appropriate EXEC 
statements naming programs to be executed. 

IBM provides seven cataloged procedures 
for use with the FORTRAN IV (H Extended) 
compiler. They are: 

• FORTXC, which includes one EXEC 
statement, to execute the compiler 

• FORTXCL, which includes two EXEC 
statements, to execute the compiler and 
the linkage editor 

• FORTXLG, which includes two EXEC 
statements, to execute the linkage 
editor and the load module 



Introduction 13 



FORTXCLG, which includes three EXEC 
statements, to execute the compiler, 
the linkage editor, and the load module 



• FORTXCG, which includes two EXEC 
statements, to execute the compiler and 
the loader 

• FORTXG, which includes one EXEC 
statement, to execute a load module 

• FORTXL, which includes one EXEC 
statement, to execute the loader 

In addition to EXEC statements, 
cataloged procedures contain DD statements 
to define data sets needed by each job 
step. 



DATA SETS 



A data set resides on one or more 

volume (s) . A volume is a unit of external 

storage that is accessible to an 

input/output device. For example, a volume 

may be a magnetic tape, disk, drum, or data 

cell. 

An input/output d evice is the piece of 
eguipment that does the recording and/or 
the reading of data from the volume. For 
example, a device may be a tape drive or a 
disk drive. 

Several input/output devices may be 
grouped together into a device class when 
the system is generated. A device class is 
referred to by a collective name. For 
example, the device class SYSDA may consist 
of all direct access devices in an 
installation; the device class SYSSQ may 
consist of magnetic tape and direct-access 
devices in an installation. 

A data set may be a system dat a set or a 
user data set . A system data set is one 
used by the system; for example, to store 
an object module. A user data set is one 
defined by the programmer for a specific 
application; for example, to store 
intermediate results during program 
processing. 



SYSTEM DATA SETS 



System data sets are used in all three 
steps of FORTRAN processing. 



Compile r Dat a Set s 



Compiler data sets are defined in DD 
statements named SYSIN, SYSPRINT, SYSPUNCH, 
SYSLIN, SYSUT1, and SYSUT2. 

• SYSIN specifies the primary input (the 
source module) to the compiler. 

• SYSPRINT specifies the output data set 
used to write listings and messages. 

• SYSPUNCH specifies the output data set 
used to punch cards or to write output 
in card image form. 

• SYSLIN specifies the data set in which 
the object module was produced by the 
compiler. 

• SYSUT1 and SYSUT2 specify utility data 
sets required by the compiler. 



Linkage Editor Data Sets 



Linkage editor data sets are defined in DD 
statements named SYSLIN, SYSPRINT, SYSLIB, 
SYSLMOD, and SYSUT1. 

• SYSLIN specifes the data set in which 
the object module was created in a 
compile step and that is to be the 
input to the link edit step. 

• SYSPRINT specifies the output data set 
used to write listings and messages. 

• SYSLIB specifies the system data set, 
SYSl. FORTLIB, that contains 
IBM-supplied FORTRAN subprograms. The 
linkage editor uses this data set to 
include FORTRAN subprograms called by 
the compiler. 

• SYSLMOD specifies the load module 
produced by the linkage editor. 

• SYSUT1 specifies a utility data set 
required by the linkage editor. 



Load Module Execution Data Sets 



Load module execution data sets are defined 
by DD statements with names in the form 
FTxxFyyy, where xx is a data set reference 
number and yyy is a sequ ence number . A 
data set reference number may range from 01 
to 99; a sequence number may range from 001 
to 999. A data set reference number 
equates the data set defined in the DD 
statement to the data set referenced in the 



14 



READ or WRITE statement in the source 
proqram. For example, the name FT08F001 
describes the data set referenced by the 
READ statement: 



I\LJt\U \ O • A t 



of their successive physical positions 
(i.e., arranged in sequential order). A 
sequential data set may reside on cards, 
tape, or a direct-access device. A FORTRAN 
source module is an example of a sequential 
data set. 



IBM-supplied cataloged procedures 
contain DD statements named FT05F001, 
FT06F001, and FT07F001 which reserve data 
set reference number 5 for an input data 
set, 6 for a printer, and 7 for a card 
punch. All other data set reference 
numbers are available to the programmer for 
the definition of other data sets. These 
standards may be changed by the individual 
installation or they may be overridden by 
the programmer. The following discussion 
describes the data sets as specified in the 
IBM- supplied cataloged procedures. 

FT05F001 defines the input data set. 
The FORTRAN programmer normally uses 5 as 
the data set reference number in the READ 
statement for input to his program. 

FT06F001 defines the data set directed 
to the printer. The FORTRAN programmer 
uses 6 as the data set reference number in 
the WRITE statement for printed output. 

FT07F001 defines the data set directed 
to the card punch. The FORTRAN programmer 
uses 7 as the data set reference number in 
the WRITE statement to direct output to the 
punch. 



Loader Data Sets 



A partitioned data set is one that is 
composed of groups of sequential data, each 
of which is called a m ember . Each member 
has a name stored in a dire ctory that is 
part of the data set and that contains the 
location of each member's starting point. 
Partitioned data sets are used as libraries 
(data sets containing a number of 
programs). SYS1.F0RTLIB, which contains 
FORTRAN subroutines, is an example of a 
partitioned data set. 

A direct-ac cess data set is one in which 
records may be accessed individually by 
specifying the position of the record 
within the data set. For example, if the 
100th record of a sequential data set is 
needed, records 1 through 99 must be 
transmitted; record 100 of a direct-access 
data set can be accessed immediately. 
Records in a direct-access data set may be 
processed in FORTRAN only by direct-access 
I/O statements but may be processed in a 
sequential fashion through use of the 
associated variable in the direct-access 
statements. Direct-access data sets may 
reside only on direct-access devices. A 
data set containing information on a 
department store' s customers, arranged 
according to charge account numbers that 
may be accessed individually, is an example 
of a direct-access data set. 



Because the loader combines two job steps, 
it uses some of the same uata sets as the 
linkage editor and the load module, such as 
SYSLIN, SYSLIB, FT05F001, FT06F001, and 
FT07F001. 

In addition, it uses a DD statement 
named SYSLOUT to specify the output data 
set used to write loader output. 



USER DATA SETS 



U ser data sets are those which the user 
requires for his particular program. For 
example, the programmer must define data 
that will be created by a program or read 
from a previous program as a user data set. 
A user data set in FORTRAN may be one of 
three types: sequential, partitioned, or 
direct-access. 

A sequential data set is one in which 
records are organized solely on the basis 



CATALOGED DATA SETS 



Any partitioned or direct-access data set 
and any sequential data set not on cards, 
may be cataloged. A cataloged data set is 
one for which certain information 
describing the data set has been placed in 
an index called the cata log. When a data 
set is cataloged, the serial number of its 
volume is entered in the catalog together 
with the data set name, thereby providing a 
cross-reference. A programmer can 
subsequently refer to the data set without 
specifying its physical location. (The 
term cataloged data set should not be 
confused with cataloged procedure. ) 



LIBRARIES OF DATA SETS 



A library is a partitioned data set 
containing a number of programs. Libraries 
supplied by IBM or the installation are 



Introduction 15 



syst em libraries ; libraries created by the 
programmer are use r libraries . 



S ystem Libraries 



System libraries most useful to a FORTRAN 
programmer are SYSl. LINKLIB, SYSl. FORTLIB, 
and SYS1.PROCLIB. 

SYSl. LINKLIB contains frequently- used 
programs, such as the FORTRAN compiler. 

SYSl. FORTLIB contains FORTRAN 
subprograms used during FORTRAN processing. 

SYS1.PROCLIB contains cataloged 
procedures and may contain user-written 
cataloged procedures as well as those 
supplied by IBM. 



User Libraries 



A user library is created by the programmer 
to serve a special application, such as 
storing frequently-used programmer- written 
programs. The programmer may adopt his own 
convention in naming his libraries. 

A programmer creates a user library and 
adds programs or subprograms to it by 
defining it on a SYSLMOD DD statement of a 
linkage edit job step. He retrieves it 
through a DD statement named STEPLIB or 
JOBLIB. STEPLIB makes the library 
accessible during one step of a job; JOBLIB 
makes the library accessible for all steps 
of the job. When JOBLIB is specified, the 
DD statement must be placed immediately 
after the JOB statement to ensure that the 
library remains available for the duration 
of the job. The STEPLIB DD statement may 
appear anywhere among the DD statements 
within a job step. 



PROGRAM OUTPUT 



In addition to object and load modules, 
jobs produce other forms of output that 



help the programmer analyze the job. The 
compile step informs the user of the 
success of the compilation by issuing 
messages, including a severity code for any 
error encountered. The following severity 
codes are associated with compilation 
messages: 



• to indicate an informational message; 
that is, no errors was detected 



4 to indicate a warning message; that 
is, a possible minor syntactic error 



was detected 



• 8 to indicate an error message; a 
syntactic error was detected 



• 12 to indicate a serious error message; 
a serious syntactic error that prevents 
program execution was detected 

• 16 to indicate an unrecoverable error 
message; compiler processing was 
terminated because of an error 

Severity codes and 4 require no action on 
the part of the programmer; the program may 
be executed. (Nevertheless, severity code 
4 messages should be corrected. ) The other 
codes require corrections before the 
program may be executed. 



The compiler may also produce output, 
such as a card deck of the object module, a 
listing of the statements in an object 
module (pseudo-assembler listing), and a 
storage map that lists the names and 
storage locations of variables appearing in 
the object module. 



.The link edit step produces a map of the 
load module and may also produce a 
cross-reference listing that shows where 
the modules making up the program 
interrelate. 

The load module step produces program 
output as required by the FORTRAN program 
and also produces any messages describing 
conditions encountered during execution. 



16 



PART I — JOB INPUT 



Introduction 17 



SUBMITTING A FORTRAN PROGRAh 



The simplest way to submit a FORTRAN 
program is by calling one of the cataloged 
procedures. The programmer calls a 
procedure by submitting: 



1. A DD statement having the name SYSIN 
immediately preceding the card deck. 
The name SYSIN defines input data. 



1. A JOB statement 



2. An EXEC statement that names the 
procedure 



3. The input to the operating system, 
such as the FORTRAN program to be 
compiled 

4. A null statement at the end of the job 

In addition, if the FORTRAN program is 
submitted in card deck form, the programmer 
must supply the following: 



2. A delimiter control statement 

immediately following the card deck to 
mark the end of card input. 

Figure 1-1 lists all the cataloged 
procedures for the FORTRAN IV (H Extended) 
compiler and an example in submitting card 
input for each of them. 

Note that in Figure 1-1, the DD 
statement named SYSIN may appear more than 
once within a job. The qualified name 
FORT. SYSIN defines the source module to the 
compile step (which is named FORT in 
cataloged procedures); the qualified name 
GO. SYSIN defines data records to be 
processed by the load module (go) step. 



Cataloged 
Procedure Name 


-J. - 


Function 


_L . 


Calling the Procedure 


FORTXC 


T 
-4- - 


Compile 


T 


//jobname JOB 

// EXEC FORTXC 

//FORT. SYSIN DD * 




r i 
| FORTRAN source module | 

L J 

/* 
// 


FORTXCL 


T 
-i- . 


Compile and 
Link Edit 


T 
J. . 


//jobname JOB 

// EXEC FORTXCL 

//FORT. SYSIN DD * 




r l 
| FORTRAN source module | 
i _ j 

/* 
// 


FORTXCLG 


T 


Compile, 
Link Edit 
and Execute 


T 


//jobname JOB 

// EXEC FORTXCLG 

//FORT. SYSIN DD * 




r i 
| FORTRAN source module | 

L J 

/* 

//GO. SYSIN DD * 

r 1 

|Data| 

L J 

/* 
// 



L J. X J 

Figure 1-1. Submitting FORTRAN Programs Through Cataloged Procedures 
(Part 1 of 2) 



Submitting a FORTRAN Program 19 



r T 

Cataloged 
Procedure Name 



Function 



Calling the Procedure 



FORTXLG 



Link Edit 
and Execute 



//jobname JOB 

// EXEC FORTXLG 

//LKED.SYSIN DD * 



first FORTRAN object module | 

j 



last FORTRAN object module | 
j 



/* 

//GO. SYSIN DD 

Data | 

/* 
// 



FORTXG 



Execute 



//jobname JOB 

//JOBLIB DD (parameters to describe library) 

// EXEC FORTXG 

//GO. SYSIN DD * 

r 1 

| Data | 

L J 

/* 
// 



FORTXCG 



Compile and 
Load 



//jobname JOB 

// EXEC FORTXCG 

//FORT. SYSIN DD * 

r 1 

| FORTRAN source module | 

l J 

/* 

//GO. SYSIN DD * 

r n 

I Data | 
l J 



/* 
// 



FORTXL 



Load 



//jobname JOB 

// EXEC FORTXL 

//LKED. SYSLIN DD (parameters) 

//GO. SYSIN DD * 

r 1 

| Data | 

L J 

/* 
// 



Figure 1-1. Submitting FORTRAN Programs Through Cataloged Procedures (Part 2 of 2) 



The FORTRAN programmer should do one 
more thing before submitting a program for 
execution. If input and output data 
consist solely of cards and printer 
listing, he should code data set reference 
numbers for FORTRAN READ and WRITE 
statements as 5 and 6 respectively. 



Cataloged procedure FORTXCLG (and FORTXLG) 
contain DD statements that allocate the 
card reader to data set reference number 5 
and the printer to data set reference 
number 6. 



20 



The programmer need do no more than the 
foregoing to process a FORTRAN program. 
Use of the cataloged procedure FORTXCLG, as 
illustrated, enables the control program to 
read the source module, read the load 
module input data set, and write program 
output and system messages on the printer. 

However, if the source module resides on 
some media other than cards (i.e., on tape 
or in a direct-access volume) or if the 
programmer needs specific data sets during 
program processing, he must make these 
private data sets available to the control 
program. To do this, he must define them 
in DD statements. The following discussion 
describes how to create and retrieve such 



DEFINING PRIVATE DATA SETS 



A private data set may be temporary or 
permanent. A temporary data set is one 
that is created and deleted in the same 
job; it is usually preferred when the 
programmer needs space temporarily to store 
data during program execution. The 
following is an example of a DD statement 
defining a temporary data set: 

//GO. FT09F001 DD DSNAME=66SET, UNIT=2311, 
// SPACE=(TRK, (5, 5) ) 

The name GO.FT09F001 identifies a data set 
to be processed by the execute step and 
links the data set to FORTRAN READ and 
WRITE statements having 9 as the data set 
reference number. DSNAME=S£SET assigns the 
name set to the data set; the symbols S£ in 
the first positions signify a temporary 
data set. The UNIT parameter indicates 
that the data set is to reside on a 2311 
device. SPACE indicates the amount of 
space allocated to the data set; space is 
allocated in number of tracks on the 2311 
device, five tracks initially and five 
additional tracks each time the data set 
needs more space. 

A permanent data set is one that is 
created and kept at the end of the job; it 
is defined when the data set is to contain 
information reguired in later jobs. To 
respecify the data set in the previous 
example as a permanent data set, the 
programmer may submit the following 
statement: 

//GO.FT09F001 DD DSNAME=SET, UNIT=2311, 
// SPACE=(TRK, (5, 5) ), 

// VOLUME=SER=DA003, 

// DISP= (NEW, KEEP) 

The DSNAME parameter names the data set 
without the £6 symbols in the first 
positions. The VOLUME parameter indicates 



that the data set is to reside on the disk 
pack having the serial number DA003. The 
VOLUME parameter is not mandatory when 
creating a data set; if it is omitted, the 
data set is assigned to any available 
volume. However, to retrieve the data set 
in a later job, the control program needs 
to know which volume to access. The DISP 
parameter indicates that the data set is 
new and is to be kept. The DISP parameter 
is mandatory; without it, the data set 
would be deleted at the end of the job. 

To retrieve the data set SET in a later 
job, the programmer changes the DISP 



lofor frnr 



iijj« i_<-> yjijW. 



//GO.FT09F001 DD DSNAME=SET, UNIT=2311 , 
// VOLUME=SER=DA003, 

// DISP= (OLD, KEEP) 

OLD indicates that the data set existed 
prior to the job. (The underscore in these 
examples is for visual aid only and is not 
part of the statement coding. ) Note that 
the SPACE parameter is not specified; it is 
used only when creating a data set. Note 
also that the UNIT and VOLUME parameters 
are repeated. The programmer can avoid 
repeating these parameters by cataloging 
the data set, that is, entering the data 
set' s name and unit and volume information 
in the control program index. To catalog a 
data set, the programmer changes the DISP 
parameter from KEEP to CATLG, i.e., 

//GO. FT09F001 DD DSNAME=SET, UNIT=2311, 
// VOLUME=SER=DA00 3, 

// DISP= (OLD, CATLG) 

Alternatively, the programmer may catalog 
the data set when he creates it, that is, 
DISP= (NEW, CATLG) , is valid. After a data 
set has been cataloged, the programmer may 
retrieve it by specifying only the DSNAME 
and DISP parameters. 

Finally, to delete the data set in a 
later job, the programmer changes the DISP 
parameter from CATLG (or KEEP) to DELETE, 
i.e. , 

//GO. FT09F001 DD DSNAME=SET, 
// DISP= (OLD, DELETE) 

DELETE indicates that the space occupied by 
the data set is to be released and made 
available for other uses at the end of the 
job. 

The operating system contains many more 
options that can be specified in the job 
control language. The programmer may 
choose those options he needs to tailor the 
system's facilities to a particular 
application. The following sections 
describe some of those options and how he 
may use them. 



Submitting a FORTRAN Program 21 



Job control statements provide a 
communications link between the FORTRAN 
proqrammer and the operating system. The 
FORTRAN programmer uses these statements to 
define a job, a job step within a job, and 
data sets required by the job. A full 
description of job control language can be 
found in the appropriate job control 
language reference publication, as listed 
in the Preface. 



three statements discussed in this section 
can contain up to four fields: name, 
operation, operand, and comments. 

Table 1-1 summarizes the function of job 
control statements. Figure 1-2 illustrates 
the format of job control statements. The 
brackets around some of the items 
illustrated indicate that those items are 
optional when using the statement. 



This section describes the job control 
statements most used by the FORTRAN 
programmer: the JOB, DD, EXEC, delimiter, 
comments and null statements. Another job 
control statement, the PROC statement, has 
a special application in FORTRAN 
processing; it assigns default values to 
program options specified in cataloged 
procedures. Because of its limited 
applicability to FORTRAN programs, the PROC 
statement is not further discussed in this 
section (see "IBM-Supplied Cataloged 
Procedures" for a discussion of this 
statement) . 



Job control statements are identified by 
the characters // in columns 1 and 2, 
except for the delimiter statement, which 
is identified by the characters /* in 
columns 1 and 2, and the comments 
statement, identified by the characters //* 
in columns 1, 2, and 3. The delimiter 
statement may contain optional comments 
preceded by one or more blanks. The null 
statement may contain only the two slashes; 
the remainder of the statement must be 
blank. The comments statement contains 
notes written by the programmer. The other 



Table 1-1. 



Job Control Statement Functions 



r t- 

I Statement I 



Function 



h + ., 



JOB | Indicates the beginning of a 

|new job and describes that job 
X __ _ 


t — 

EXEC | Marks the beginning of a job 

| step and indicates the program 
jor cataloged procedure to be 
jused 

X- - - 


T 

DD | Describes data sets and 

| controls device and volume 

| assignment 

X 


T 

Delimiter | Separates data sets in the 
| input stream from control 
| statements; it appears after 
| each data set in the input 
| stream 
X -- - - 


T 

Null | Indicates the end of a job 

X 


T 

Comment | Contains miscellaneous remarks 
| written by the programmer; it 
jean appear before or after any 
j control statement 



L X J 



| FORMAT 

j. + 

//Name Operation [Operand] [Comment] 

//[Name] Operation Operand [Comment] 
/* [Comment] 
// 

//* Comment 
Figure 1-2. Job Control Statement Formats 



APPLICABLE CONTROL STATEMENTS 

JOB 

EXEC,DD 

delimiter 

null 

comments 



u x j 



22 



The name field begins in column 3, 
immediately following the //. 

The name field assigns a name to the 
statement, identifying it to other 
statements and to the operating system. A 
name consists of from one to eight 
alphameric characters or the characters #, 
$, or a. The first character of the name 
must be alphabetic. A DD statement may 
contain a qualified name which is two names 
joined together with periods; the name 
FORT.SYSIN is an example of a qualified 
name. 



The operation field oegins in any column 
after the name field and is preceded and 
followed by one or more blanks. 

The operation field identifies the type 
of control statement, e.g., JOB, DD, or 
EXEC. 

The operand field begins in any column 
after the operation field and is preceded 
and followed by one or more blanks. The 
operand field identifies system options 
requested by the programmer. Options are 
specified through one or more parameters 
separated by commas. 

Parameters may be either po sitiona l or 
keyword. Positional parameters must appear 
in a fixed order and are identified, or 
given meaning, by their position in that 
order. A keyword parameter is composed of 
an identifying keyword, an equal sign (=), 
and a value. Parameters may also comprise 
a number of subparameters, which can be 
either positional or keyword. 

The comments field begins in any column 
after the operand field (or the /* in the 
delimiter statement) and is preceded by one 
or more blanks. The comments field may 
contain any information that is considered 
helpful. There is no required syntax for 
comments . 

All statements (except the null 
statement) may be continued onto succeeding 
cards, using the following rules: 

1. Interrupt operands after a completed 
parameter or subparameter, including 
the comma that follows it, at or 
before column 71. 

2. If comments are desired in the same 
statement as an interrupted operand 
field and there is sufficient room, 
leave one or more spaces after the 
comma that follows the last parameter, 
and then code the comments. 

3. For an interrupted comment, code any 
nonblank character in column 72. For 
an interrupted operand, the nonblank 



4. 



5. 



character in column 7 2 is optional. 
If a nonblank character is not coded 
in column 72 of an interrupted 
operand, but the conventions outlined 
in the next two items are followed, 
the job scheduler will treat the next 
statement as a continuation statement. 



Code the identifying characters // in 
columns 1 and 2 of the following card 
or card image. 



Continue the interrupted operand 
beginning in any column from 4 throuah 
16. 



Note that excessive continuation cards (or 
card images) should be avoided whenever 
possible to reduce processing time for the 
control program. 



SYNTAX FOR PARAMETER DESCRIPTION 



In describing the syntax for parameters, 
this publication follows the conventions 
listed in the following paragraphs. 



1. 



The set of symbols listed below are 
used to define control statements, but 
are never coded in a control 
statement. 



a. 


hyphen 


- 


b. 


logical or 


1 


c. 


underscore 




d. 


braces 


{ } 


e. 


brackets 


[ ] 


f. 


ellipsis 


... 


g. 


superscript 


i 



2. 



The special uses of these symbols are 
explained in paragraphs numbered from 
4 to 10. 

Uppercase letters and words, numbers, 
and the set of symbols listed below 
are coded in a control statement 
exactly as shown in the statement 
definition. 



a. 
b. 
c. 
d. 
e. 
f. 

g- 



apostrophe 

asterisk 

comma 

equal sign 

parentheses 

period 

slash 



( ) 
/ 



Using Job Control Statements 23 



3. Lowercase letters, words, and symbols 
appearing in a statement definition 
represent variables for which specific 
information is substituted when the 
control statement is coded. 

Exampl e: 

DSNAME= filename 
may be coded as 

DSNAME=MYNAME 

4. Hyphens join lowercase letters, words, 
and symbols to form a single variable. 

Example : 

PGM=pr ogr am- name 
may be coded as 

PGM=MYNAME 

5. Stacked items or items separated from 
each other by the "logical or" symbol 
represent alternatives. Only one such 
alternative should be selected. 

For example : 



or an alternate designation: 

{A|B|C> 

The above two examples have the same 
meaning and indicate that either A or 
B or C should be selected. 

6. Brackets also group related items; but 
everything within the brackets is 
optional and may be omitted. 

Example : 

ALPHA=([A|B|C],D) 

The preceding example indicates that a 
choice can be made among the items 
enclosed within the brackets or that 
the items within the brackets may be 
omitted. If B is selected, the result 
is ALPHA=(B,D). If no choice is made, 
the result is ALPHA=(,D). 

7. An underscore indicates the standard 
default option. If a default option 
is selected, it need not be coded in 
the actual statement. 



If the user wants the DECK option, he 
will have to specify it; if he wants 
the NODECK option, he may specify it, 
but he does not need to do so. 

8. Braces group related items, such as 
alternatives. 

Example : 

ALPHA=({A|B|C},D) 

The above example indicates that a 
choice must be made among the items 
enclosed within the braces. If A is 
selected, the result is ALPHA=(A, D). 
If C is selected, the result can be 
either ALPHA=(C,D) or ALPHA=(,D). 

9. An ellipsis indicates that the 
preceding item or group of items can 
be repeated many times. 

Example : 

ALPHA [, BETA]... 

The preceding example indicates that 
ALPHA can appear alone or it can 
appear followed by , BETA optionally 
repeated many times in succession. 

10. A superscript refers to a description 
in a footnote. 

Example : 

(NEW) 1 
)old( 
)mod( 
(shr) 

11. Blanks are used to improve the 
readability of control statement 
definitions. Unless otherwise noted, 
blanks may not appear in a statement 
definition. 



PARM= 



DECK 
NODECK 



JOB STATEMENT 



A JOB statement initiates the beginning of 
a job and assigns a name to it. 

The JOB statement may also contain the 
following information: 

1. Accounting information relative to the 
job 

2. Programmer's name 

3. The type of system messages to be 
written 



24 



4. Conditions for terminating the 
execution of the job 

5. Assignment of input and output classes 

6. Job priority 

7. Main storage requirements 

8. A time limit for the job 

Figure 1-3 illustrates the format of the 
JOB statement. Table 1-2 summarizes the 
functions of the JOB statement. Figure 1-4 
shows sample JOB statements. 

The job name is always required. All 
other information is optional unless made 
mandatory by each installation. 



Naming the Job 



and, if used, must be the first ones 
specified in the operand field. All other 
parameters are keyword parameters and may 
appear in any order. 



Specifying Ac counting Information 



Accounting information is used to store 
installation-required accounting 
procedures. It is specified as the first 
parameter in the operand field. The 
parameter has no predefined format; it 
consists of a string of up to 142 
characters. If it contains anv special 
characters (valid members of the character 
set not alphabetic or numeric) other than a 
hyphen, it is enclosed in apostrophes. 

An example of the accounting parameter 



Jobname identifies the job to the operating 
system. Because a multiprogramming 
environment permits many jobs to operate 
concurrently, the programmer should select 
a unique jobname for each job. 

The accounting information and 
programmer* s name are positional parameters 



•215, 46WX819' 

If this parameter is not present but the 
programmer's name is, a comma is required 
to indicate the omission. If both 
parameters are omitted, no commas are 
required. (The accounting field may be 
required, at the installation' s option. ) 



T T 

| Operation | Operand 



Name 



//jobname 



JOB 



Posit ion al Parameters 

[ , accounting-information] 

[ , programmer-name] 

Keyword Parameters 
[MSGLEVEL=(x, y) 3 
[COND= ( ( code, operator ) . . . 
[CLASS= job- class] 
[PRTY= job-priority] 
[MSGCLASS=x] 
[REGION=region-size] *- 
[TIME= (minutes, seconds) ] 2 
t ADDRSPC=REAL | VIRT] 3 



)] 



*-MVT and VS only. 
2MVT and VS2 only. 
3 VS only. 



Figure 1-3. Job Statement Format 



//CLH1 JOB NY237413,C.L. HARVEY, MSGLEVEL=1 

//CLH2 JOB , HARVEY,COND=(8,EQ),REGION=100K, TIME=60, 
// CLASS=H , PRTY=1 

//PROGRAM JOB 873, • COVER-RAMSEY' , MSGLEVEL= (1 , 1 >, MSGCLASS=C, 
// PRTY=10 

Figure 1-4. Sample JOB Statements 



1 



Using Job Control Statements 25 



Table 1-2. JOB Statement Functions 

Purpose 



r r 

| Specification | 



How to Specify 



h- 



■+- 



jobname 



To identify the job to the 
operating system. 



One to eight alphameric (alphabetic or 
numeric) characters, the first of which must 
be alphabetic or one of the extended 
alphabetic characters #, a, or $. 



accounting- 
information 



To identify the account 
number or other accounting 
information relating to the 
job. 



Up to 142 characters; if any special 
characters other than a hyphen, enclose in 
apostrophes. 

See "Specifying Accounting Information" 
for details. 



programmer- 
name 



To identify the person 
submitting the job. 



Up to 20 characters; if special characters 
other than a period, enclose in apostrophes, 



MSGLEVEL 



To specify the type of 
system messages (i.e., job 
control statements, 
diagnostic messages, 
termination messages) to be 
written as part of the 
output listing. 



MSGLEVEL=(x,y) , where x is 0, 1, or 2, to 
indicate which job control statements and 
diagnostic messages are to be written, and 
is or 1 to indicate whether termination 
messages are to be written. 

See "Specifying System Messages" 
for details. 



COND 



To specify those conditions 
that are to result in 
program termination. 



COND=( (code, operator )...) , where code is a 
number between and 4095 (usually 0, 4, 8, 
12, or 16) and operator is a 2-character 
value that represents a comparison to be made 
between code and a return code issued by the 
operating system. If the comparison is true, 
the job is terminated. 

See "Specifying Condition Codes to 
Terminate a Job" for details. 



CLASS 



To assign an input class to 
the job. 



CLASS= job-class, where job-class is an alpha- 
betic character A thru O assigning the class 
represented by that character to the job. 



PRTY 



To assign a priority to the 
job. 



PRTY=job-priority, where job-priority is a 
number through 13 assigning the priority 
represented by that number to the job; the 
higher the number, the greater the priority, 



MSGCLASS 



To assign an output class 
to the job. 



4- 



MSGCLASS=x, where x is an alphabetic or 
numeric character assigning the output class 
represented by that character to the job. 



TIME 



(Part 1 of 2) 



To assign a time limit to 
the job. 



TIME= (minutes, seconds) , where minutes is a 
number up to 1439, and seconds is a number up 
to 59. 



26 



Table 1-2. JOB Statement Functions (Part 2 of 2) 



r T" 

| Specification | 
j. + . 



Purpose 



-+- 



How to Specify 



REGION 



To assign storage to a job 
operating in the MVT or VS 
environment. 



For MVT, REGION= (nnnnn^Kf . nnnnn^K] ) ; where 
nnnnn ± K is a value up to 163 8 3K and indicates 
the amount of storage to be allocated <K=10 24 
bytes) ; nnnnn 2 K is a value up to 2048K and 
indicates the amount of additional storage to 
be allocated, usually from an IBM 2361 Core 
Storage device. For an IBM 2361 Model 1, 
nnnnn 2 K may be a value up to 1024K; for an 
IBM 2361 Model 2, nnnnn 2 K may be a value up 
to 2048K. 

For VS # REGION=valueK, where valueK 
represents the number of contiguous 1024-byte 
areas of real or virtual storage to be 



L _i_ -L. v>^Ct L-^VAi 



See "Assigning Storage to a Job Under MVT" 
for details. 



ADDRSPC 



To specify the mode of 
operation, real or virtual, 
of the VS control program. 



ADDRSPC=REAL for real mode, and ADDRSPC=VIRT 
for virtual mode. 



Spec ifyi n g the Pr ogrammer' s Name 



The programmer's name is specified as the 
second parameter in the operand field. It 
consists of a string of up to 20 
characters. If it contains any special 
characters other than a period, it is 
enclosed in apostrophes. 

Examples of the programmer-name 
parameter are: 

J.SMITH 

' COVER- RAMSAY' 

If this parameter is not present, no 
comma is required to note the omission. 



Specifying System Messages 



The MSGLEVEL parameter is used to specify 
whether job control statements and 
termination messages are to be written. 

MSGLEVEL has the format : 



procedures, are written. When x=2, only 
job control statements submitted with the 
job (not taken from cataloged procedures) 
are written. 

The letter y represents a termination 
message code and indicates whether 
termination messages are to be produced. 
The value of y may be or 1. When y=0, no 
termination messages appear for normal 
completion of the job; termination messages 
appear for abnormal termination. When y=l, 
termination messages appear under any 
circumstances . 

If the parameter is omitted, the default- 
values for x and y are those established by 
the installation. 

An example of MSGLEVEL is: 

MSGLEVEL=(2,0) 

The example states that only control 
statements submitted with the job are to be 
written, and that termination messages are 
to be written only if abnormal termination 
occurs. 



MSGLEVEL=(x, y) 

The letter x represents a job control 
message code and indicates whether job 
control statements are to be written along 
with program statements. The value of x 
may be 0, 1, or 2. When x=0, the JOB 
statement, job control statement errors, 
and diagnostic messages are written. When 
x=l, all job control statements, including 
those appearing in called cataloged 



Spec ifying Condition Codes to Terminate a 
Job 



The COND parameter is used to specify which 
condition codes terminate processing. It 
is useful in helping the programmer reduce 
computing time by making job continuation 
dependent upon successful completion of a 
previous job step. 



Using Job Control Statements 27 



The system issues a number, called a 
return code, at the end of each job step. 
The return code is an indication of how 
well the job step ran, i.e., whether it 
completed processing normally or whether 
error conditions were detected. The COND 
parameter indicates a comparison to be made 
between the return code and the condition 
code specified in COND; if the condition is 
met, the job is terminated. 



CLASS has the format: 

CLASS=a 

The letter a indicates an alphabetic 
character A through O. The meaning of the 
characters is determined by each 
installation at system generation time. If 
the parameter is omitted, the default class 
A is assumed. 



COND has the format: 



PRTY has the format; 



COND= ( (code, operator) [ , (code, operator) ] . . . ) PRTY=n 



Code consists of a number. Operator 
consists of two alphabetic characters 
indicating a mathematical relationship 
between the condition code and the return 
code. There are six operators, as follows 



Operator 


Meaning 


GT 


greater than 


GE 


greater than or equal to 


EQ 


equal to 


NE 


not equal to 


LT 


less than 


LE 


less than or equal to 



Up to eight sets of codes and operators may 
be specified. 



An example of COND is: 

C0ND=((8,LT) ) 

The example states that if 8 is less than 
the return code issued by the system, the 
job is to be terminated (any return code 
less than or equal to 8 allows the job to 
continue ) . 



The letter n indicates a number from 
through 13; the higher the number, the 
greater the priority. Whenever possible, 
priority 13 should be avoided. This number 
is used by the system for special 
processing. If the parameter is omitted, a 
standard default estaolished by each 
installation is assumed. 

An example of the CLASS and PRTY 
parameters is: 

CLASS=C, PRTY=10 



Assigning an Ou tput Writer 



The MSGCLASS parameter is used to assign 
messages to a specific output writer 
through a class code. 

The system assigns messages to a variety 
of output devices according to the output 
class. By assigning an output class, the 
programmer directs output to a specific 
device. 



MSGCLASS has the format: 



Assigning Job Priority 



The CLASS parameter is used to assign a job 
class; the PRTY parameter assigns a 
priority within a class. 

When a job is introduced to the system 
it is assigned to an input queue according 
to a code called a class. Main storage is 
divided into a number of areas, each of 
which handles jobs assigned a certain 
class. When one job has completed 
processing, that storage is given to the 
next job having the same class. The 
programmer determines the order in which 
jobs are entered into the system by 
specifying the CLASS parameter. He can 
further refine the order in which jobs 
within a class are entered into the system 
by specifying the PRTY parameter. 



MSGCLASS=x 

The letter x indicates an alphabetic or 
numeric character. The meaning of the 
characters is determined by each 
installation at program installation time. 
If the parameter is omitted, the default 
class A (usually directed to a printer) is 
assumed. 

An example of MSGCLASS is : 

MSGCLASS=B 



Assigning a Time Limit t o a Job 



The TIME parameter is used to assign a 
processing time limit. If the job is not 



28 



completed in the time specified, it is 
terminated. 

TIME has the format: 

TIME= (minutes, seconds) 

Minutes and seconds are expressed in 
numeric characters. Minutes cannot exceed 
1439; seconds cannot exceed 59. If a job 
is expected to run longer than 24 hours, 
the programmer may code TIME=1440 to 
eliminate job timing. If the TIME 
parameter is omitted, a default limit 
established by each installation is 
assumed. 

If time is specified in minutes only, 
the delimiting parentheses are not required 
(e.g., TIME=10>. If time is specified in 
seconds only, the parentheses and a comma 
denoting the omission of minutes are 
required (e.g., TIME=(,50)). 

An example of TIME is : 

TIME=(10,30) 

The example states that the job may run up 
to a maximum time of ten minutes and thirty 
seconds. 



Assigning Storage to a Job Under MVT 



Under MVT, storage is assigned according to 
the needs of each particular job. The 
REGION parameter is used to specify the 
amount of storage to be allocated. If the 
parameter is omitted, a default size 
establishes. j_>y eacn instaxxation is 
assumed. 

The programmer may assign storage to 
individual job steps rather than to the 
entire job by coding the REGION parameter 
in each EXEC statement instead. 



REGION has the format: 

REGION= (nnnnriiK [ , nnnnn 2 K] ) 

The term nnnnnj.K indicates the number of 
contiguous 1024-byte areas to be allocated. 
The number specified may be from one to 
five digits but cannot exceed the total 
storage available. Parentheses are not 
required if only nnnnn^K is specified 
(e.g., REGION=200K). 

The term nnnnn 2 K is used only if the 
installation has specified hierarchy 
support. Hierarchy support indicates that 
storage may be allocated from two regions, 
one known as hierarchy 0, the other as 



hierarchy 1. Hierarchy is always 
assigned from main storage and is specified 
by nnnnn ± K. Hierarchy 1 may be assigned 
either from main storage or from the large 
core storage device, IBM 2361 Model i or 2, 
and is specified by nnnnn 2 K. If hierarchy 
1 is assigned from main storage, the 
combined value of nnnnn ± K and nnnnn 2 K 
cannot exceed the total storage available; 
if hierarchy 1 is assigned from the IBM 
2361, nnnnn ± K cannot exceed 16383 and 
nnnnn 2 K cannot exceed 1024 for an IBM 2361 
Model 1 or 2048 for an IBM 2361 Model 2. 

If storage is requested only from 
hierarchy 1, a comma is required to 
indicate the absence of nnnnnjK (e.g., 
REGION=(,200K) ). 

An example of REGION is : 

REGION= (100K, 100K) 

The example states that 200K bytes of 
storage are to be assigned, 100K from 
hierarchy and 100K from hierarchy 1. 



Assigning Storage to a Job Under VS 



Storage can be allocated under the VS 
control programs by use of the ADDRSPC and 
REGION parameters. 

The ADDRSPC parameter is used with the 
VS control programs to indicate whether a 
job or job step is to be run in real or 
virtual mode. This parameter takes the 
form ADDRSPC=REAL|VIRT, where REAL 
specifies real mode and VIRT specifies 
virtual mode. Most FORTRAN programs are 
run in virtual mode as described under 
"Operating System Control Programs" in the 
Introduction, and the default value for 
this parameter is ADDRSPC=VIRT. When 
ADDRSPC=REAL is coded on a JOB or EXEC 
card, all the pages of the job or job step 
in question are brought into real storage 
simultaneously and remain there for the 
duration of the job or job step. 

The REGION parameter for the VS control 
programs takes the form REGION=valueK, 
where value K indicates the number of 
contiguous 1024-byte areas of either real 
or virtual storage (depending on the mode 
of operation of the control program) to be 
allocated to the job or job step in 
question. There is no hierarchy support 
under VS. 

Under VS1, in virtual mode, virtual 
storage is automatically allocated in 
partitions of installation-determined size 
in a manner analogous to the allocation of 
main storage under MFT. The REGION 



Using Job Control Statements 29 



parameter, if coded, is ignored when VSl is 
run in virtual mode. When VSl is run in 
real mode, the REGION parameter must be 
coded to indicate the number of contiguous 
1024-byte areas of real storage to be 
allocated, and value K may not exceed the 
total real storage available. If the 
REGION parameter is not coded, a default 
region of installation-determined size will 
be allocated. 



The parameter indicating the program or 
cataloged procedure to be executed is the 
only one required and must be the first one 
specified; all others are optional and may 
appear in any order. 



The EXEC statement also contains the 
following information: 



Under VS2, in virtual mode, the REGION 
parameter may be used to specify the number 
of contiguous 1024-byte areas of virtual 
storage to be allocated, and value K is 
limited only by the addressing range of the 
System/370. Under VS2 in real mode, the 
REGION parameter must be coded to indicate 
the number of contiguous 1024-byte areas of 
real storage to be allocated, and value K 
may not exceed the total real storage 
available. If REGION is not coded, in 
either virtual or real mode, a default 
region of installation-determined size will 
be allocated. 

For a further discussion of storage 
allocation under the VS control programs, 
see the publication OS/ VS Job Management 
Services, Order No. GC28-0617. 



1. A job step name (a step name is 

required only when it is necessary for 
a later job step to reference 
information from this job step) 



2. Compiler, linkage editor, or other 
options passed to the job step 



3. Conditions for bypassing the execution 
of the job step 



4. Accounting information relative to the 
job step 



5. A time limit for the step or cataloged 
procedure 



EXEC STATEMENT 



6. Main storage requirements 



An EXEC statement indicates the beginning 
of a job step and names the program or 
cataloged procedure to be executed. 



Figure 1-5 illustrates the format of the 
EXEC statement. Table 1-3 summarizes the 
function of the EXEC statement. Figure 1-6 
shows sample EXEC statements. 



-T T" 

1 Operation | 
4 + . 



Name 



Operand 



//[stepname] 



EXEC 



Positional Parameter 
([PROC=] procedure-name) 
(PGM=program-name J 

Keyword Parameters 
[ PARM=' opt ion [, option] ... * 
[ACCT=( accounting- information) ] 
[COND=( (code, operator!, stepname] ) (. . 
[DPRTY=step-priority] *- 
[TIME= (minutes, seconds) J 1 
[REGION=region-size] 2 
[ADDRSPC=REAL| VIRT] 3 



. )) 



*MVT and VS2 only. 
2 MVT and VS only. 
3 VS only 



Npte ; To indicate the step of a cataloged procedure to which an option applies, any 
of the keyword parameters can be followed by a period and the name of the step to be 
executed; e.g., PARM. procstep=option 



Figure 1-5. EXEC Statement Format 



30 



Table 1-3. EXEC Statement Functions (Part 1 of 2) 



| Specification 
y 



Purpose 



How to Specify 



4- 



■-! 



j o Lcpiiciiuc: 



iTo permit other job steps to refer 
to: 

1. The condition code resulting 

from this step, and 

2. The data sets in this step. 



One to eight alphameric characters, 
the first of which must be 
alphabetic or one of the extended 
alphabetic characters S, #, or $. 



procedure -name 



To name the cataloged procedure to 
be executed. A procedure-name 
initiates the processing of a 
series of job control statements 
that has been previously written 
in the system library. 
SYS1. PROCLIB, and cataloged in the 
system catalog. 



procedure-name, or 
PROC=procedure-name, where 
procedure-name is the name of the 
cataloged procedure. 

See "Naming the Cataloged Procedure 
or Program to be Executed" for 
details. 



prog ram- name 



To name the program to be 
executed. 



PGM=program-name, where 
program-name is the name of a 
program. 

See "Naming the Cataloged Procedure 
or Program to be Executed" for 
details. 



PARM 



To specify program options. 



PARM=' option [, option] ...' , where 
option names a particular program 
option that is to be in effect 
during processing. 

See "Specifying Program Options" 
for details in how to specify 
options. See the sections 
"Compilation" and "Linkage Editor 
and Loader" for descriptions of 
available options. 



ACCT 



To identify accounting information 
relating to the job step. 



ACCT=( value [, value] ) where value 
indicates accounting information. 

See "Specifying Accounting 
Information" for details. 



COND 



To specify those condition codes 
from previous job steps that will 
cause this job step to be 
bypassed. 



COND= 

( (code, operator!, stepname] )(...)), 
where code is a number between 
and 4095, operator is a two- 
character value that represents a 
comparison to be made between code 
and a return code issued by a 
preceding job step or the operating 
system, and stepname is the name 
of the preceding job step issuing 
the return code. 

See "Specifying Condition Codes 
to Bypass a Job Step" for details. 



Using Job Control Statements 31 



Table 1-3. EXEC Statement Functions (Part 2 of 2) 



| Specification 



Purpose 



4- 



How to Specify 



DPRTY 



To assign a priority to the job 
step. 



DPRTY= (step-priority, n) , where 
step-priority is a number from 
to 15 that the system converts 
into an internal priority, and n 
is a number from to 15 that is 
added to the internal priority to 
establish a step priority. 



TIME 



To assign a time limit to the job 
step. 



TIME= (minutes, seconds) , where 
minutes is a number up to 1439, 
and seconds is a number up to 59. 



4 



REGION 



To specify the amount of main 
storage to be allocated to a job 
step operating in the MVT 
envi r onment . 



For MVT, REGION=(nnnnniK[, nnnnn 2 K] ) , 
where nnnnn^K is a value up to 
16383K and indicates the amount of 
storage to be allocated; nnnnn 2 K 
is a value that usually indicates 
the amount of additional storage 
to be allocated from an IBM 2361 
Core Storage Device. For an IBM 
2361 Model 1, nnnnn 2 K may be any 
value up to 1024K; from an IBM 2361 
Model 2, nnnnn 2 K may be any value 
up to 2048K. The combined value of 
of nnnnn^K and nnnnn 2 K may not 
exceed 16383. 

For VS, REGION=valueK, where valueK 
represents the number of contiguous 
1024-byte areas of real or virtual 
storage to be allocated. 



ADDRSPC 



To specify the mode of operation, 
real or virtual, of the VS 
control program. 



ADDRSPC=REAL for real mode, 
ADDRSPC=VIRT for virtual mode. 



//STEPA EXEC PARM= (MAP, DECK) 

//DO EXEC PROC=FORTXCLG, PARM. LKED=DECK, ACCT=24 8 



// 
// 



EXEC PGM=MYPROG, ACCT=NY12345, REGION=128K, TIME=3 , 
COND= ( 8, GT, HISPROG ) 



L j 



Figure 1-6. Sample EXEC Statements 



Naming an EXEC Statement 



Stepname identifies the EXEC statement to 
other control statements and permits them 
to refer to information contained in the 
-job step. Steps within cataloged 
procedures should be given unigue names so 
that identification to the correct step can 
be easily made. 



Naming the Cataloged Procedure or Progra m 
to be Executed 



The PROC parameter is used to specify a 
cataloged procedure; PGM, to specify a 
program. 



The format of PROC is: 



32 



PROC=procedure-name 

where : 

procedure - name 

names the cataloged procedure to be 
executed. 

The word PROC is optional; if it is 
omitted, PROC is assumed. For example, the 
following are equivalent: 

// EXEC PROC=FORTXCLG 
// EXEC FORTXCLG 

Note tiiat a cataxoge»~i procedure uoss not in 
itself execute a program; it permits 
previously written job control statements 
to be inserted into the job stream at the 
point that the procedure was called. The 
job control statements in the cataloged 
procedure should contain at least one EXEC 
statement having the PGM parameter which 
names the program to be executed. 

| The PGM parameter may specify any load 
I module name accessible to the operating 
system. For example, PGM identifies the 
FORTRAN IV (H Extended) compiler as 
PGM=IFEAAB; PGM identifies the linkage 
editor as PGM=IEWL. 



current job, "stepname" is the name of 
the job step, and "ddname" is the name 
of the DD statement defining the 
program. (The "stepname" cannot refer 
to a job step in another job. ) The 
program referred to must be a member 
of a partitioned data set. 

This form of a program name is most 
familiar to a FORTRAN programmer in an 
execution step following a link edit 
step. The linkage editor stores the 
load module in the data set defined by 
the SYSLMOD DD statement. For 
example, in the following statements, 
STEP 4 executes the linkage editor. 
The linkage editor stores the 
resulting load module named ARCTAN 
into the partitioned data set, MATH, 
defined by the SYSLMOD DD statement. 
STEP5 indicates that the program to be 
executed (ARCTAN) is defined in the DD 
statement SYSLMOD in the job step 
named STEP4 of the current job. 



//XYZ 



//STEP 4 
//SYSLMOD 



JOB , JSMITH,C0ND=(7,LT) 



EXEC 
DD 



PGM=IEWL 
DSNAME=MATH< ARCTAN) 



The format of PGM is 



//STEP5 



EXEC PGM=*. STEP 4. SYSLMOD 



(program- name 
PGM= <*. stepname. ddname 

(*. stepname. procstep. ddname 



where : 

program- name 

names a program that resides in either 
the system library or a private 
library. The system library is a 
partitioned data set named 
SYS1.LINKLIB that stores 
frequently-used programs such as 
IFEAAB and IEWL. Private libraries 
are partitioned data sets that store 
groups of programs that are used by 
individual users. 

*. stepname. ddname 

names a program found on a data set 
defined in a previous job step of the 
current job. The * indicates the 



stepname. procstep. ddname 

names a program found on a data set 
defined in a previously executed step 
of a cataloged procedure. The * 
indicates the current job, "stepname" 

o.o i—iic; jiaiuc <_ij_ uiic jyjyj o ucp uiau 

invoked the cataloged procedure, 
"procstep" is the name of a step 
within the cataloged procedure, and 
"ddname" is the name of a DD statement 
that defines the data set within that 
procedure step. Consider a cataloged 
procedure, FORT, containing the 
following statements: 



//COMPFIL 


EXEC 


PGM=IExxx 


//SYSPUNCH 


DD 


SYSOUT=B 


//SYSPRINT 


DD 


SYSOUT=A 


//SYSLIN 


DD 


DSNAME=LINKINP 



Using Job Control Statements 33 



//LKED 
//SYSLMOD 



EXEC 
DD 



PGM=IEWL 
DSNAME=RESULT ( ANS ) 



PARM= * option [ , option ] . . . ' 
PARM. procstep=* option [, option] . 



where : 



Assume that the following 
statements appear in the input stream: 



//MAIN JOB JOB , SMITH , COND= ( 7 , LT ) 
//SI EXEC PROC=FORT 



//S2 EXEC 
//FT03F001 DD 
//FT01F001 DD 



PGM=* . SI . LKED. SYSLMOD 
UNIT=PRINTER 
UNIT= INPUT 



Statement Si calls the cataloged 

procedure FORT, 
nt S2 indicates that the program to be 
executed is found on a data set described 
by the DD statement SYSLMOD, located in the 
procedure step LKED of the cataloged 
procedure FORT, which was invoked by the 
statement SI. Conseguently, the load 
module ANS in the data set RESULT is 
executed. 



procstep 

is used when a cataloged procedure has 
been specified in the PROC parameter. 
Specified PARK options are to apply to 
the job step in the cataloged 
procedure identified by procstep. For 
example, the following indicates that 
changes are to be made to the FORT 
step: 

PARM. FORT= ' NOOBJECT ' 



opti on 

indicates either a keyword that has an 
intrinsic value to the program (e.g., 
LIST, SOURCE) or a keyword that is 
assigned a value by means of an equal 
sign or a pair of parentheses, for 
example, LINECOUNT(nn) . The option 
field may contain up to 100 characters 
of information. 



The field of PARM options may be 
enclosed in either apostrophes or 
parentheses according to the following 
rules: 



Specifying Program Options 1. 



The PARM parameter is used to specify 

program options applicable during execution 

of a job step. Program options increase 

the flexibility of a program by allowing 

the programmer to choose the form of input 

and output, the type of output, and 

otherwise tailor the program to his needs. 

A FORTRAN programmer may specify options 

for the FORTRAN compiler, the linkage 2. 

editor, and the system loader. 

See the sections "Compilation" and 
"Linkage Editor and Loader" for a 
discussion of these options. 

If a PARM parameter is not specified, 
the program being executed assumes default 
values established at program installation 
time. When the user's installation 
receives a copy of the program product, it 
will contain the default options indicated 
in this publication. (Default values are 
shown underlined in this publication. ) The 
user's installation can customize the 3. 

compiler for its needs and default options 
may be permanently established at that 
time. 



PARM has the format; 



If no individual option contains a 
special character (such as an equal 
sign or parenthesis) , the programmer 
may enclose the field in either 
apostrophes or parentheses. For 
example, either of the following 
formats is valid: 

PARM=' LIST, SOURCE, NODECK ' 
PARM=(LIST, SOURCE, NODECK) 

If an option contains a special 
character, the programmer may enclose 
either that option in apostrophes and 
the entire field in parentheses, or 
the entire field in apostrophes. For 
example, either of the following is 
valid: 

PARM=(LIST, 'LINECOUNT(50) ', SOURCE) 
PARM=' LIST, LINECOUNT ( 50 ) , SOURCE' 

(This publication adopts the 
convention of enclosing the entire 
field in apostrophes. ) 

If the PARM parameter is continued 
onto a following card, the programmer 
must enclose the entire field in 
parentheses and any individual options 
containing special characters in 
apostrophes. For example, only the 
following is valid: 



34 



PARM= ( LIST, • LINECOUNT ( 50 ) • , SOURCE, 
NODECK) 



Specifying C ondit ion Co des to Byp ass a Job 
Step 



4* If onlv one option is specified the 
programmer need not enclose the option 
in either apostrophes or parentheses 
(except if that option contains a 
special character, in which case 
apostrophes are mandatory) . For 
example, any of the following is 
valid: 



PARM=LIST 

PARM^LIST' 

PARM=(LIST) 



Specifying Accounting Information 



The ACCT parameter is used to specify 
accounting information for a job step. 



Like the accounting parameter in the JOB 
statement, the field may contain up to 142 
characters and is enclosed in apostrophes 
if it contains any special characters other 
than a hyphen. Unlike the JOB statement 
parameter, ACCT is a keyword parameter and 
may appear anywhere in the operand field. 



ACCT has the format: 



ACCT=( value [.value] . - , ) 

ACCT. procstep= (value [ , value] . . . ) 

where : 

procstep 

indicates in which step of a cataloged 
procedure the accounting information 
is to apply. 

value 

indicates some accounting information, 
such as the account number to be 
charged for machine time. If value 
contains any special characters, it 
must be enclosed in apostrophes. If 
only one value is specified, it need 
not be enclosed in parentheses. 

An example of ACCT is: 

ACCT='NY432 777' . 

Note that a blank is considered a special 
character, requiring the use of 
apostrophes. 



J.i«v~ will/ £/lAJ. Millie l_^ J_ J.O 

condition codes are to cause job step 
processing to be bypassed. 

Like the COND parameter in the JOB 
statement, the parameter lists codes and 
operators to test the return code issued by 
the system. Unlike the JOB statement 
parameter, if the condition is met, the job 
step is not terminated but bypassed. 

COND has the format: 

COND= ( ( code, operator [ , stepname] )(...)) 
COND. procstep= ( (code, operator [ , stepname] ) 
(...))..)) 

where : 

procstep 

is used when a cataloged procedure has 
been specified in the PROC parameter, 
to indicate in which step of the 
procedure the condition applies. 

stepname 

indicates the name of a previous job 
step that issued the return code to be 
tested against the code in COND. 

The meanings of code and operator are 
the same as described for the COND 
parameter of the JOB statement. 

An example of COND is: 

COND.GO=( (4, LT, FORT) (4,LT, LKED) ) 

The example states that if 4 is less than 
the return code issued by FORT or LKED, the 
job is to be terminated (any return code 
less than or equal to 4 allows the job to 
continue). 



A ssigni ng Step Priority 



The DPRTY parameter is used to assign a 
dispatching priority to a job step. The 
dispatching priority determines the order 
in which job steps will use main storage 
and CPU (central processing unit) 
resources. If the parameter is omitted, 
each job step is assigned the same priority 
as the job, either through the JOB 
statement PRTY parameter or by default. 

DPRTY has the format: 

DPRTY= ( step-priority, n ) 

DPRTY. procstep= (step-priority, n) 



Using Job Control Statements 35 



where: 

procstep 

is used when a cataloged procedure has 
been specified in the PROC parameter 
to indicate in which step of the 
procedure the dispatching priority 
applies. 

step-priority 

is a number from 1 through 15 
representing a priority. This 
subparameter has the same meaning as 
the PRTY parameter in the JOB 
statement; that is, if PRTY=10 is 
coded in the JOB statement and 
DPRTY=10 is coded in the EXEC 
statement, job and step priority are 
the same. If the step priority is to 
be different from that assigned to the 
job, a different number is assigned. 
The step-priority is converted by the 
system into an internal priority; the 
higher the number the greater the 
priority. Whenever possible, the 
number 15 should be avoided; this 
number is reserved for certain system 
tasks. 



is a number from to 15 that is added 
to the internal priority to establish 
the dispatching priority. 

If the first value is omitted but the 
second is specified, a comma is required to 
indicate the absence (e.g., DPRTY=(,12) ) . 
If the second value is omitted, the 
delimiting parentheses are not required 
(e.g., DPRTY=3). 

An example of DPRTY is: 

DPRTY=(10,9) 

The example states that the number 10 is to 
be converted into an internal priority and 
the number 9 is to be added to the 
resulting priority. 



Assigning a Time Limit to a Job Step 



been specified in the PROC parameter 
to indicate in which step of the 
procedure timing considerations apply. 

If procstep is omitted, the time limit 
applies to the entire procedure. 

The meanings of minutes and seconds are 
the same as described for the TIME 
parameter of the JOB statement. 

An example of TIME is : 

TIME. FORT=5 

The example states that the FORT step of a 
cataloged procedure is to have a time limit 
of five minutes. 



Assigning Storage to a Job S tep Under MVT 



Under MVT the REGION parameter is used to 
specify the amount of storage to be 
allocated to a job step. A REGION 
parameter specified on a JOB statement 
overrides any EXEC statement REGION 
parameters. 

REGION has the format: 

REGION= (nnnnn A K [ , nnnnn 2 K] ) 

REGION. procstep= (nnnnn^Kt , nnnnn 2 K] ) 

where : 

procstep 

is used when a cataloged procedure has 
been specified in the PROC parameter, 
to indicate in which step of the 
procedure storage allocation applies. 

If procstep is omitted, the allocation 
applies to all steps of the procedure. 

The meanings of nnnnniK and nnnnn 2 K are 
the same as described for the REGION 
parameter of the JOB statement. 

An example of REGION is: 

REGION=100K 



The TIME parameter is used to assign a time 
limit to the step. If not completed in the 
time specified, the step is terminated. 

TIME has the format: 

TIME= (minutes, seconds) 

TIME. procstep= (minutes, seconds) 

where: 

procstep 

is used when a cataloged procedure has 



The example states that 100K bytes of 
storage are to be allocated to the job 
step. 



Assignin g Stor age to a _Job Step Under VS 



Under the VS control programs, the REGION 
and ADDRSPC parameters can be used to 
specify the amount and type of storage to 
be allocated to individual job steps. The 



36 



REGION and ADDRSPC parameters specified on 
JOB statements override those specified on 
EXEC statements. Rules for coding them are 
the same as those described for the JOB 
statement. 



2. The location of the data set in the 
system's resources 



3. The name of the data set 



DD STATEMENT 



DD statements describe and identify data 
sets and the volumes in which they reside. 
They also provide instructions for their 
proper handling and disposition. DD 
statements supply information which is used 
hv the "iob scheduler to allocate 
input/output devices and by data management 
to supervise the input/output operations. 

The DD statement is concerned with the 
data set, records within the data set, and 
the location of the data set. 

The DD statement specifies the following 
information: 

1. A name for the DD statement 



4. The status of the data set at the 
beginning and end of the job step 

5. Labeling information for the data set 
volume 

6. Data set allocation to optimize the 
use of input/ out put channels 

7. The type of input/output device on 
which the data set resides 

8. Space allocation for data sets on 
direct access devices 

9. Characteristics of the records in the 
data set 

Figure 1-7 illustrates the format of the 
DD statement. Figure 1-8 shows sample DD 
statements. Table 1-4 summarizes the 
functions of the DD statement parameters. 



T T 

| Operation | Operand 



Name 



// (ddname 

(procstep. ddname 



DD 



Positional Parameters 



DATA 
DUMMY 



Key wordParame t e r s 

7 VOLUME) lSER= serial- number) 



(vol j (F 



REF=ddname 
DDNAME =dd na me 
(DSNAME) 



Jdsn ) 



=data- set-name 



DISP=(subparameter-list) 

SYSOUT=x 

[LABEL=(subparameter-list> ] 

[COPIES=number] 1 

[ SEP= ( ddname [ , ddname] . . . ) ] 

[ DLM=de limit er] x 

[UNIT= (device [, SEP= (ddname, ...)]>] 

[SPACE=(subparameter-list) ] 

tDCB=(subparameter-list) ] 



JiVS only. _ j 

Figure 1-7. DD Statement Format 



Using Job Control Statements 37 



r 

Exa m ple 1 ; Directing a data set to the printer: 

//SYSPRINT DD SYSOUT=A 
Example 2 ; Creating a temporary data set (created and deleted within the same job) 

//FT14F001 DD DSNAME=66TEMP,UNIT=SYSSQ 
Example 3 ; Creating a permanent data set: 



//FT8 9F001 DD DSNAME=MINE, VOLUME=SER=8 342, UNIT=2400, 
// DISP= (NEW, KEEP) , LABEL=( , SL, EXPDT=71365) 

Exa mple 4 : Creating a permanent cataloged data set: 

//FT31F001 DD DSNAME=MATRIX, DISP=( NEW, CATLG, DELETE) , 

// UNIT=2311,VOLUME=SER=AA69 l SPACE=(TRK, (50, 5, ROUND) ) , 

// DCB=(RECFM=FB,LRECL=604,BLKSIZE=1208) 

Example 5 : Retrieving the permanent uncataloged data set defined in Example 3: 
//FT89F001 DD DSNAME=MINE, VOLUME=SER=8342, UNIT=2400, DISP= (OLD) 

Example 6 : Retrieving the cataloged data set defined in Example 4: 
//FT37F001 DD DSNAME=MATRIX,DISP= (OLD) 



L. 



Figure 1-8. Sample DD Statements 



38 



Table 1-4. DD Statement Functions (Part 1 of 3) 

Purpose 



r T" 

| Specification | 



How to Specify 



h 



H 

One to eight alphameric characters, | 
the first of which must be 
alphabetic or one of the extended 
alphabetic characters #, a, or $. 



ddname 



To identify the DD statement to 
other job control statements 
that may need to refer to it. 



procstep. ddname 



To identify the DD statement in 
the particular jobstep identified 
as procstep. 



Procstep and ddname are each 
specified as one to eight alpha- 
meric characters, the first of 
which must be alphabetic or one of 
the extended alphabetic characters. 
Procstep and ddname are separated 
by a period ( . ) . 



To indicate that the data set 
appears in the input stream 



vvne.il • -lo uacU| 

• The data set must appear 
immediatedly following the DD * 
statement ; 

• No other parameter except the 
DCB parameter has meaning on 
the DD statement. 

See "Data Set Location" for 
details. 



DATA 



To indicate that the data set 
appears in the input stream and 
contains job control statements 
that are to be read as data and 
not as instructions. Used, for 
example, when job control state- 
ments are being entered into the 
system catalog as a cataloged 
procedure. 



When DATA is used, 

• The data set must appear 
immediately following the DD 
DATA statement; 

• No other parameter except the 
DCB parameter has meaning on 
the DD statement. 

See "Data Set Location" for 
details. 



DLM 



To specify a delimiter other than 
/* to terminate a group of data 
in the input stream. 



DLM=delimiter, where delimiter 
is any combination of two char- 
acters that will indicate the end 
of a group of data in the input 
stream. 



DUMMY 



To identify a data set on which 
no operations are to be 
performed (such as to defer 
processing a data set in a 
program segment that has already 
been tested). 



See "Data Set Location' 
details. 



for 



VOLUME 



To identify the volume in which 
the data set resides. 



VOLUME=SER=serial-number, where 
serial- number consists of one 
through six alphameric characters 
identifying the volume, or 
VOLUME=REF=ddname, where ddname is 
the name of another DD statement 
and indicates that the data set is 
to share the same volume as the 
data set defined in ddname. 



See "Data Set Location' 
details. 



for 



Using Job Control Statements 39 



Table 1-4. DD Statement Functions (Part 2 of 3) 



r t - 

| Specification | 



Purpose 



How to Specify 



j. 1 + ^ 



DDNAME | To indicate that the data set is | DDNAME= ddname, where ddname is the 
| to have the same characteristics | name of another DD statement or the 
j as a data set defined in another | characteristics of the data set 
| DD statement. | defined in ddname. 
i__ __ _ ___ 4. ______ 


T T 

DSNAME | To name the data set or a member | DSNAME=data-set-name, where 

| of a partitioned data set. | data-set-name is the name of a 

j | permanent data set, a temporary 

| | data set, a member of a partitioned 

| | data set, or a reference to a data 

| j set defined in another DD 

| j statement. 

| | See "Data Set Identification" for 
| | details. 

!____ _ _L_ ____ 


T T ____ 
DISP | To indicate whether the data set | DISP=(subparameter-list) , where 
j is new or old, and whether it j subparameter-list indicates: 
| is to be kept or released at the | 

| end of the job step. | • The disposition of the data set 
| | at the beginning of the job 
| | step (i.e., whether new or old) 
| j • The disposition to be made of 
| | the data set at the end of the 
j j job step (i.e., whether to be 
j j kept, deleted, or passed to 
| | another job step) , 
j | • The disposition to be made of 
j | the data set if abnormal 
| j termination occurs (i.e., 
| j whether to be kept or deleted). 

j | See "Data Set Disposition" for 
| | details. 
4 4 

SYSOUT | To assign the output of the data | SYSOUT=x, where x is an alphabetic 
j set to an output class. j or numeric character assigning the 
j | output class represented by the 
| | character to the data set. 
| | SYSOUT=A is usually specified for 
| j printer output, SYSOUT=B for card 
j | punch output. 

j | See "Data Set Disposition" for 
j j details and VS options. 
4 4 

COPIES | To obtain between 1 and 255 hard | COPIES=number, where number is 

| copies of the output data set. j between 1 and 255. 
4 4 

LABEL | To assign such information as | See "Data Set Labels" for details. 

| labels, whether the data set is j 

j protected from unauthorized j 

| processing, and how long the data j 

| set should be kept. | 
4 4 

SEP | To assign the data set to a | SEP= (ddname [, ddname] ...) , where 
j different input/ out put channel | ddname is the name of another DD 
| from the data set defined in | statement. 
| ddname. | 



l J. X J 



40 



Table 1-4. DD Statement Functions (Part 3 of 3) 

Purpose 



r T" 

| Specification | 



How to Specify 



j. 

ilTNTT 



4 



device or device class on which 
the data set resides. 



j i i, 

where device is a number or name 
identifying the device and ddname 
is the name of another DD 
statement. SEP=ddname. . . is used 
only for data sets on direct access 
devices and only when the data set 
is not to share device access arms 
with the data set defined in 
ddname. 

See "Assigning a Data Set to an 
Input/Output Device" for details. 



SPACE 



Used only for a data set in a 
direct access volume, to 
allocate space to the data set. 



SPACE=(subparameter-list) , where 
subparameter-list indicates 
whether space is to be allocated to 
a specific address or to any 
location in the direct access 
volume, and the amount of space to 
be allocated. 

See "Assigning Space to a Data Set 
on a Direct Access Volume" for 
details. 



DCB 



To identify the characteristics 
of the records in a data set. 



See "Defining Record 
Characteristics" for details. 



DD Statement Uses 



DD statements define the following types of 
data sets: 

1. System data sets. These include 
SYSIN, SYSPRINT, SYSPUNCH, SYSLIN, 
SYSLMOD, SYSUT1, and SYSUT2. These 
data sets are used by various system 
components as work areas and temporary 
storage areas, and are necessary for 
the execution of the compiler, linkage 
editor, and loader. 

2. FORTRAN load module data sets. If the 
FORTRAN programmer uses cataloged 
procedures and the standard data set 
reference numbers (5 for card input, 6 
for printer output, and 7 for 
punched-card output) , there is no need 
to supply DD statements for those data 
sets; they are contained in the 
cataloged procedures. 

If the FORTRAN programmer uses other 
forms of input/ out put, such as 
magnetic tape or disk, it is necessary 
to define those data sets with DD 



3. 



statements. The DD statements are 
equated to the data set reference 
numbers through the DDNAME parameter 



t«tV-i i cY>. T ft. 



xuv-nuxi. .1-^:0 



the DD statement. 



The ddname format for data sets used 
in FORTRAN load module execution is : 



FTxxFyyy 

where xx is the data set reference 
number and yyy is a FORTRAN sequence 
number (usually 001). The data set 
reference number is nothing more than 
a numeric means of equating FORTRAN 
input/output statements with the 
proper data set definition; it has 
nothing to do with the physical 
address of the device or its type. 

A sequential data set on which a dump 
can be written in the event of an 
abnormal termination. Definition of 
this data set automatically requests 
the dump facility; if no data set has 
been defined for dump output, it is 
bypassed. A ddname of SYSUDUMP 
specifies a dump of the problem 
program area. A ddname of SYSABEND 



Using Job Control Statements 41 



specifies a dump of the problem 
program area and the system nucleus. 

4. Concatenated data sets (data sets 

temporarily joined together), usually 
consisting of one or more private 
libraries and the system library 
SYS1.LINKLIB. In other words, the 
system library and the specified 
libraries will be combined temporarily 
to form one library. A ddname of 
STEPLIB will retain the concatenated 
library for the duration of the job 
step; a ddname of JOBLIB will retain 
the concatenated library for the 
duration of the job. 

In theory, all DD statement parameters 
are optional; that is, no one parameter is 
required for all DD statements. In 
practice, however, some parameters are 
required to describe a function properly. 
For example, to create a permanent data 
set, the DISP, UNIT, and DSNAME parameters 
are required; to create a permanent data 
set on a particular direct access volume, 
the VOLUME and SPACE parameters are also 
required. 



Nami ng a DD Sta t ement 



The ddname identifies the statement to 
other control statements and relates the 
data set to I/O statements in the FORTRAN 
source module. The name may be a qualified 
name with the format procstep. ddname to 
associate the DD statement with a cataloged 
procedure job step, such as FORT. SYSIN. 



Data Set Location 



The *, DATA, or VOLUME parameters are used 
to specify a data set's location. The 
DUMMY parameter is used to inhibit I/O 
operations on a data set. 

The * parameter defines a data set in 
the input stream, usually a card deck or a 
data set in card image form. An example of 
the * parameter is: 

//DSET1 DD * 

The data set is physically placed after the 
DD * statement, and it must be followed by 
a /* statement to denote the end of the 
data set. 

The DATA parameter also defines a data 
set in the input stream. It is used in 
place of the * when the data set contains 
records having the characters // in columns 
1 and 2. 



An example of DATA is: 

//DSET2 DD DATA 

When either the * or the DATA parameter 
is used, no other operand in the DD 
statement has meaning except the DCB 
parameter which may specify block and 
buffer information for the data set, e.g., 

DCB=(BLKSIZE=800,BUFNO=2) 

(The DCB parameter is discussed in the 
section "Defining Record Characteristics."* 

In addition, under VS, the DLM parameter 
may be coded with the * or DATA parameter 
to allow the programmer to specify a 
delimiter other than /* to terminate a 
group of data in the input stream. By 
assigning a different delimiter in the DLM 
parameter, the programmer can include a 
standard delimiter (/*) as data in the 
input stream. 

The DLM parameter has the format: 

DLM=delimiter 

where delimiter is any combination of two 
characters that will indicate the end of a 
group of data in the input stream. (If the 
delimiter contains any special characters, 
it must be enclosed in apostrophes. ) 

An example of the use of the DLM 
parameter is: 

//DD1 DD *,DLM=AA 



Data 



AA 



This example shows the DLM parameter 
being used to assign the characters AA as 
the valid delimiter for the data defined in 
the input stream by DDL 

VOLUME specifies the location of a data 
set not in the input stream (i.e., it is 
used for data sets residing on tape or in 
direct-access volumes). The parameter is 
required when creating a new data set if 
the programmer wants the data set assigned 
to a specific volume; if the parameter is 
omitted, the data set is assigned to any 
available volume. The parameter is 
required when retrieving an existing data 
set except if the data set has been 
cataloged. The VOLUME parameter contains 
many subparameters. Two subparameters most 
useful to the FORTRAN programmer are SER 
and REF. SER specifies the volume serial 
number. REF specifies the name of another 
data set or the name of another DD 



42 



statement and indicates that more than one 
data set is to share the same volume. 



The format of VOLUME=SER is: 

VOLUME=SER=serial-number 

where: 

serial-number 

is a 1 to 6 character serial number. 



An example is 



VOLUME— SER— DAI 234 



The format of VOLUME=REF is: 

dsname 
VOLUME=REF= j * . ddname 

*. stepname. ddname 

* . stepname. procstep. ddname J 

See Table 1-5 for an explanation of the 
data set name formats. 



An example of VOLUME=REF is: 

VOL=REF=*.DDNAM 

The example states that the data set is to 
share the same volume as the data set 
described on the DD statement DDNAM in the 
current job. Note that VOLUME may be 
abbreviated VOL. 



For a discussion of the other 
subparameters available in the VOLUME 
parameter, see the appropriate job control 
languaqe reference publication, as listed 
in the Preface. 



The DUMMY parameter is used to prevent 
input /output operations on the data set. 1 
WRITE statement is recognized but no data 
is transmitted. A READ statement is 
recognized but permits further processing 
only if the END= option is specified; if 
the option is not specified, a read causes 
an end of data set condition and 
termination of load module execution. 



Data Set Identification 



DSNAME and DDNAME are used to identify a 
data set. 



DSNAME specifies either the name of the 
data set or the name of an earlier defined 
DD statement that identifies this data set. 
DDNAME specifies the name of a DD statement 
to be defined later which is to identify 
this data set. 



DSNAME has the format: 



Sdsname > 

dsname (member ) t 

SSdsname | 

S&dsname (member) , 

(DSN J J*. ddname 

f * . stepname. ddname ' 
V *. stepname. procstep. ddname' 



See Table DD3 for an explanation of the 
data set name formats. 



Examples of DSNAME are: 

DSNAME=DSET 

DSN=LIB(PR0G1) 

DS NAME= * . FORT . S YSLIN 

The first example states that the data set 
name is DSET. The second example states 
that the data set is a partitioned data set 
named LIB and that the DD statement defines 
the member named PROG1. The third example 
states that the data set is the one defined 
in the DD statement named SYSL1N occurring 
in the job step named FORT. (This last 
example is how loader cataloged procedures 
define the object module resulting from the 
compilation job step. ) 



DDNAME has the format: 

DDNAME=ddname 

where : 

ddname 

is the name of another DD statement. 



When this parameter is used, no other 
parameter except the DCB parameter may be 
specified on the DD statement. 



An example of DDNAME is : 

DDNAME=FT 8F 1 

The example states that data set definition 
is to be found on the DD statement named 
FT08F001. 



Using Job Control Statements 43 



Table 1-5. Data Set Names 



Format 



Description 



Example 



dsname 1 

dsname( element) 2 

SSdsname 2 

£ Sdsname (element) 2 

♦.ddname 1 

*. stepname. ddname* 



*. stepname. 
procstep. ddname 3 - 



A data set named dsname 

A member of a partitioned data set 

A temporary data set, to be deleted at the 
end of the job 

A member of a temporary partitioned data 
set 

A data set defined in another DD statement 
within the current job step 

A data set defined in another DD statement 
but in an earlier job step named stepname 
of the current job 

A data set defined in a DD statement in 
the cataloged procedure step named 
procstep called by the job step named 
stepname. 



NAME 

MYPROG(PROGA) 

66TEMP 

6STEMPP(PR0G) 

*. SYSPRINT 

* . STEPA. SYSPRINT 

* . STEPA. LKED. SYSPRINT 



^-This format may appear in the DSNAME, VOLUME, and DCB parameters 
2 This format may appear in the DSNAME parameter only 



Data Set Disposition 

The SYSOUT and DISP parameters indicate the 
status of a data set. 

SYSOUT directs data set output to a unit 
record device such as a printer or a card 
punch device class. Table 1-6 summarizes 
device classes. 

The format of SYSOUT is: 

SYSOUT=x 

where: 



is an alphabetic or numeric character 
that assigns the data set to the 
device class represented by the 
character. 

An example of SYSOUT is: 

SYSOUT=B 

The example states that the data set is to 
be directed to the device class B, usually 
a card punch. 

Under the VS1 and VS2 control programs, 
the programmer has the additional options 
of using the SYSOUT parameter to specify a 



program in the system library which will 
write the output data set, as well as a 
special output form on which the data set 
is to be printed or punched. 



The format of the VS SYSOUT parameter 



is: 



SYSOUT= ( x [7 program name"! [ , form number] ) 



where: 



is as described above. 

, program name 

is the member name of a program in the 
system library (other than the system 
output writer) that is to write the 
output data set to a unit record 
device. 



specifies that the system output 
writer is to write the output data set 
to a unit record device, and a form 
number follows. 

, form number 

is from 1 through 4 alphabetic or 
numeric characters (including a, $, 
and #) which specify that the output 



44 



data set is to be printed or punched 
on a special output form. 

The parentheses are optional if the program 
name and form number are omitted. 

An example is: 

SYSOUT=(F, ,7402) 

The example specifies that the data set is 
to be written by the system output writer 
to a unit record device corresponding to 
class F. The data set is to be printed on 
a special form. The form number is 7402. 

Under VS, the programmer may also use 
the COPIES parameter in conjunction with 
the SYSOUT parameter to obtain between 1 
and 255 copies of the output data set. 

The format of the COPIES parameter is : 

COPIES=number 
where number may be between 1 and 255. 
An example is: 

//RECORD DD SYSOUT=W, COPIES=32 

The example is a request for 32 copies of 
the data set RECORD to be produced by a 
unit record device corresponding to class 

w. 

If fewer than 1 or more than 255 copies 
are specified, or if the COPIES parameter 
is coded without an associated SYSOUT 
parameter, the job will be canceled. 

The DISP parameter indicates the status 
of a data set not on a unit record device. 
It contains three subparameters, the first 
describes the data set status at the 
beginning of the job step, the second the 
disposition of the data set at the end of 
the step, and the third the data set 1 s 
disposition if an abnormal termination 
occurs. 

The format of DISP is: 



OLD 





UEw" 




"", KEEP " 




~,KEEP 


DISP= ( 


OLD 




, DELETE 




, DELETE 




SHR 




, CATLG 




, CATLG 




MOD 




, UNCATLG 




j UNCATLG 








,PASS 







MOD 



describes a data set that existed 
before the current job step. 



describes an existing data set which 
resides on a direct-access volume that 
is also available to other 
concurrently-operating jobs. 



describes a sequential or partitioned 
data set that is to be added to. 
Before the first input/output 
operation occurs, the data set will be 
automatically positioned after the 
last record. 



KEEP 



specifies that the data set is to be 
retained for future use in other jobs. 
KEEP is the default value for old data 
sets. 

DELETE 

specifies that the space occupied by 
this data set is to be released and 
made available for other uses. If the 
data set was cataloged, the entry for 
it will be removed from the catalog. 
If the data set resides on a 
direct-access volume, the entry for 
the data set will be removed from the 
volume table of contents. Once this 
disposition has taken place, the data 
set will have ceased to exist. DELETE 
is the default value for new data 
sets. 

CATLG 

specifies that a catalog entry that 
points to the data set is to be 
entered in the system catalog. The 
data set can then be referred to by 
name in subsequent jobs or job steps. 
CATLG implies KEEP. 

UNCATLG 

specifies that the catalog entry that 
points to the data set is to be 
removed from the system catalog. 
UNCATLG implies KEEP. If the data set 
resides on a direct-access volume, the 
entry for the data set will remain in 
the volume table of contents. The 
area occupied by the data set is still 
reserved for the data set, and is not 
released. 



where : 



PASS 



NEW 



describes a data set that is being 
created in the current job step. If 
the status is NEW, that subparameter 
may be omitted (NEW is the assumed 
value) by indicating its absence with 
a comma. 



specifies that the data set is to be 
used in a later job step. A DD 
statement in a later job step can 
reference the data set using the 
DSNAME parameter format 
*. stepname. ddname. The final 
disposition of the data set should be 
given in the last job step that uses 



Using Job Control Statements 4 5 



the data set. When a data set is in 
the PASS status, the volume on which 
it resides remains mounted. 

If the third subparameter is not 
specified, the disposition is the same as 
that specified in the second subparameter; 
if the second subparameter specifies PASS, 
the status of the data set reverts to the 
status it had before the job step that 
passed it. In other words, if the data set 
had an initial disposition of OLD, MOD, or 
SHR, the data set is kept; if it had an 
initial disposition of NEW, it is deleted. 

Examples of the DISP parameter are: 

DISP= ( NEW, CATLG, DELETE ) 
DISP= (OLD, DELETE, KEEP) 
DISP=SHR 

The first example specifies a new data set 
that is to be cataloged; if abnormal 
termination occurs, information in the data 
set is considered useless and the data set 
is deleted. The second example specifies 
an existing data set that is to be deleted; 
if abnormal termination occurs, information 
in the data set is needed and the data set 
is retained so that it may be resubmitted. 
The third example specifies an existing 
data set that is to be shared with other 
jobs; it is implicitly retained. Note that 
if only the first subparameter is specified 
the delimiting parentheses may be omitted. 



Table 1-6. Device Class Names 

T 



r t 

Class 
Name 



I— 



SYSSQ 



SYSDA 



Class Function 



Reading, Writing 
(sequential) 



Reading, Writing, 

Updating 

(direct) 



Printed Line 
Output 



Card Image 
Output 



Device Type 



Magnetic Tape 
Direct Access 



Direct Access 



Printer 
Magnetic Tape 
Direct Access 



Card Punch 
Magnetic Tape 
Direct Access 



A ssigning a Data Set to an Input/Output 
Device 



The UNIT parameter assigns a data set to a 
device. The device may be identified by 
its identification number (e.g., 2100 for 
tape, 2311 for a disk), or by its device 



class name (e.g., SYSSQ for devices 
containing sequential data sets). A device 
class is a group of input/output devices 
performing similar functions, which is 
given a collective name. Device class 
names are assigned at program installation 
time. See Table 1-6 for a summary of 
device class names supplied by IBM. 

For data sets residing on direct access 
devices, the UNIT parameter may also 
specify those data sets that are not to 
share the same device access arms, thereby 
increasing operating efficiency for data 
sets whose input/output operations occur at 
the same time; these other data sets are 
identified by naming the DD statements 
defining them. 

The format of the UNIT parameter most 
applicable to FORTRAN programs is: 



UNIT ( 



where : 



/device-type 
(group-name 



[, SEP=(ddname, ...)]) 



device type 

identifies an input/output unit by its 
device number. For example, to 
request a 2400 Magnetic Tape Device, 
UNIT=2400 is specified; to request a 
2311 Disk Storage Unit, UNIT=2311 is 
specified. See "Appendix C: Unit 
Types" for a list of device types that 
can be specified in the UNIT 
parameter. 

groupname 

identifies a device class name, such 
as SYSSQ. 

ddname 

identifies a DD statement defining a 
data set that is to be on a separate 
device access arm from the data set 
defined in the current DD statement. 
Up to eight ddnames may be specified. 

Examples of UNIT are: 

UNIT=SYSDA 

UNIT= ( 2311, SEP=DDNAME1 , DDNAME3 ) 

The first example states that the data set 
may be assigned to any unit in the SYSDA 
device class. Note that parentheses are 
not required if only one value is 
specified. The second example states that 
the data set is to be assigned to a 2311 
device and is to use different access arms 
from the data sets described in DD 
statements DDNAME1 and DDNAME 3. 

For a discussion of the other 
subparameters available in the UNIT 
parameter, see the appropriate job control 



46 



language reference publication, as listed 
in the Preface. 



CONTIG 

is a keyword indicating that space is 
to be assigned contiguously within the 
volume. 



Assigning Sp ac e to a Data Set on a Direct 
Access Volume 



The SPACE parameter is used to allocate 
space to data sets residing on direct 
access volumes. This parameter is required 
when defining a new data set on a direct 
access volume. 

To assign space anywhere within a 
volume, the SPACE parameter has the format: 



(TRK 
SPACE=( <CYL 

( block- length 



( , primary [ ^secondary] [ , directory] ) 
[,RLSE] 
[, CONTIG] 
[, ROUND]) 



where 



TRK 



specifies that space is to be 
allocated in number of tracks. 



ROUND 

is a keyword indicating that space to 
be allocated must be equal to one or 
more cylinders. 

Examples of this form of the SPACE 
parameter are: 

SPACE=(TRK, (10,10,2)) 
SPACE=(400, (5, 5),CONTIG,RLSE) 

The first example states that space is to 
be allocated in tracks: 10 tracks are to foe 
allocated initially; 10 additional tracks 
are to be allocated as needed; additional 
space is to be reserved for 2 records of a 
directory. 

The second example states that space is 
to be allocated according to the size of 
each block of records (400 bytes). Space 
to accomodate five blocks is to be 
allocated initially. Space to accomodate 
five more blocks is to be allocated as 
needed up to a maximum of 15 times. Space 
is to be assigned contiguously. Unused 
space may be released at the end of the job 
step. 



CYL 



specifies that space is to be 
allocated in number of cylinders. 



block-length 

is a number indicating the average 
length of a block of records in the 
data set; the system is to allocate 
space according to the block length 
specified. 

primary 

is a number indicating the amount of 
tracks, cylinders, or blocks to be 
allocated. 



Data Set Labels 



The LABEL parameter is used to specify 
label information for a data set. Labels 
are used by the control program to store 
information about the data set and to 
identify the volume on which it is 
contained. Data sets on direct access 
volumes always have labels, data sets on 
magnetic tape volumes usually have labels, 
and data sets on unit record devices never 
have labels. 



secondary 

is a number indicating the amount of 
tracks, cylinders, or blocks to be 
allocated if additional space is 
required. Additional space is 
allocated up to fifteen times. 

directory 

is a number indicating the amount of 
blocks of 256-byte areas to be 
allocated for the directory of a 
partitioned data set. 



RLSE 



is a keyword indicating the unused 
space may be released at the end of 
the job step. 



The LABEL parameter consists of four 
positional subparameters and one keyword 
subparameter (any subparameter not 
specified must have its position noted by a 
comma, except the last subparameter). 

The first subparameter indicates the 
position of the data set relative to other 
data sets sharing the volume (tape only) . 
The second subparameter identifies the type 
of label associated with the data set. The 
third specifies whether the data set is 
protected against unauthorized processing. 
The fourth specifies whether the data set 
is to be processed for input or output 
operations only. The fifth specifies a 
date when the data set may be released. 



Using Job Control Statements 47 



LABEL has the format: 
LABEL= ( [sequence number") 



[f 



", SL 


r, password] 


", in " 


,NL 


,OUT 


, AL 




_» 


,BLP 






J 







r, EXPDT=yydddl 
|_, RETPD=nnnn J 



where: 



sequence- number 

is used only for data sets residing on 
magnetic tape to specify which data 
set is to be processed in a volume 
containing more than one data set 
(e.g., 3 specifies the third data 
set). The subparameter may consist of 
up to four digits. If the data set is 
the first or only data set in the 
volume, the subparameter need not be 
coded; the default value is 1. 



specifies the absence of a 
subparameter when following 
subparameters are specified. 



SL 



NL 



AL 



BLP 



specifies that the data set has 
standard system-created labels. 



specifies that the data set has no 
labels. 



specifies that the data set has ASCII 
labels (American National Standard 
Code for Information Interchange, a 
system of coding computer-processed 
characters differently from the IBM 
standard EBCDIC). ASCII data sets can 
reside only on magnetic tape. 



specified that label processing for 
the data set is to be bypassed. 



PASSWORD 

specifies that the data set is 
protected by a password. In order to 
access the data set the operator must 
issue the correct password on the 
system console. Password-protected 
data sets must have standard labels. 



IN 



specifies that the data set is to be 
processed for input operations only. 
IN will be recognized only if the 
first input/output operation is a 
READ. If it is not a READ, IN is 



ignored and both input and output 
operations are permitted; if it is a 
READ, any subsequent WRITE will be 
treated as an error and job processing 
is terminated. IN also permits a 
password-protected data set to be read 
(if the correct password is supplied) 
and avoids the need of operator 
intervention when reading a data set 
having a high expiration date (for an 
explanation of the expiration date, 
see the description of EXPDT). IN 
must be specified to read a 
partitioned data set or number. 



OUT 



specifies that the data set is to be 
processed for output operations only. 
OUT will be recognized only if the 
first input/output operation is a 
WRITE. If it is not a WRITE, OUT is 
ignored and both input and output 
operations are permitted. If it is a 
WRITE, any subsequent READ will be 
treated as an error and job processing 
is terminated. OUT must be specified 
to create a partitioned data set or 
member and WRITE operations only may 
be specified. 

EXPDT=yyddd 

specifies a date when the data set can 
be deleted. The date is expressed as 
a 2-digit number for the year and a 
3-digit number for the number of the 
day in the year (e.g., 72100 indicates 
that the data set may be released on 
the 100th day of the year 1972). 

RETPD=nnnn 

specifies the number of days that the 
data set is to be kept. 

Examples of LABEL are: 

LABEL=(3,SL) 

LABEL=(,SL, ,OUT,EXPDT=71196) 

The first example states that the third 
data set of a magnetic tape volume has 
standard labels. The second example 
specifies a data set with standard labels 
which is used only for output operations 
and which may be released on the 196th day 
of 1971. 



Assigning Channel Use 



The SEP parameter indicates a data set that 
is to be assigned to a different channel 
from other data sets. 

A channel is a small control unit that 
manages data transmission operations 
between a number of input/output devices 



48 



and the system* s central processing unit. 
Processing time may be shortened by the use 
of separate channels; assigning data sets 
whose input/output operations occur at the 
same time to separate channels increases 
the speed of input/output operations. 

SEP has the format: 

SEP= ( ddname, . . . ) 

where: 

ddname 

is the name of a DD statement whose 
data set is not to share the same 
channel as the data set being defined. 
Up to eight ddnames may be specified. 
If only one ddname is specified, the 
enclosing parentheses are not 
reguired. 

An example of SEP is: 

SEP= ( N AMEA , NAMEB , NAMED ) 

The example states that the data set being 
defined is to be assigned to a separate 
channel from the data sets defined on DD 
statements NAMEA, NAMEB, and NAMED. 



Defining Record Characteristics 



The DCB parameter defines characteristics 
of records in a data set. The parameter 
may specify the following: 

• Record format, i.e., whether records 
are fixed-length (all records in the 
data set are of equal length), 
variable-length (records are of 
different length), or undefined-length 
(no record length information has been 
stated) . 

• Record length. For variable-length 
records, the record length specifies 
the length of the largest record. 

• Block information, i.e., whether 
records are accessed individually 
(unblocked) or in groups (blocked), and 
the block size of blocked records. 

• The number of buffers to be assigned to 
a data set when data is transmitted 
between system devices. 

• Information identifying ASCII data 
sets. 

• Options to describe characteristics of 
data sets residing on tape. 



• Options to describe characteristics of 
data sets residing on direct access 
devices. 

• Characteristics of data sets to be 
taken from another data set. 

If the parameter is not specified, default 
values are supplied according to the data 
set description presented by other 
parameters in the DD statement. Table Cl 
in the section "Compilation" lists DCB 
defaults for compiler data sets; Table 1-12 
in the section "Load Module Execution" 
lists DCB defaults for load module data 
sets. 

The format of the DCB subparameter is : 

DCB=( [data-set-name] 

[ , RECFM= record- f ormat] 

t, LRECL=record-length] 

[ , BLKSI ZE=block-length] 

[, BUFNO=number-of-buf fers] 

[ , BUFOFF=block-pref ix] 

[, DEN=tape-density] 

[ , TRTCH=tape-recording-technigue] 

[, DSORG=direct-access-organization] 

[,OPTCD=optional- services] 



The data-set-name subparameter indicates 
that DCB attributes are to be taken from a 
data set defined earlier. Other DCB 
subparameters may be coded on the same DD 
statement to override any of the attributes 
taken from the earlier data set. The 
data-set-name subparameter is specified as: 



data-set-name= 



dsname j 

* . ddname f 

* . s tepname . ddname I 
*. stepname. Drocstep, ddname) 



The form that data-set-name may take is 
summarized in Table 1-5. 



An example of dsname is : 

DCB=* . STEP1 . SMITH2 

The example states the data set is to have 
the same characteristics as the data set 
defined in the DD statement SMITH2 
appearing in job step STEPl. 

RECFM is specified as follows: 
] LmJ [T] 



RECFM= 

where : 
F 



[b] [s: 



indicates fixed-length records. 



Using Job Control Statements 49 



indicates variable-length EBCDIC 
records. 



indicates variable-length ASCII 
records. 



For variable- length records, LRECL 
indicates the length of the longest record, 
plus four for a segment control word. A 
four- byte Segment control word precedes 
each variable- length record and specifies 
the actual length of the record. For 
undefined records LRECL is omitted. 



indicates undefined- length records. 



indicates that records are blocked. 
B may not be specified for 
undefined-length records. 



indicates spanned records, i.e., a 
record spans over two or more blocks. 
S may be specified only for 
variable- length EBCDIC records. 



An example of LRECL is: 

LRECL=84 

This example states that the record length 
is 84 bytes. 

BLKSIZE is specified as: 

BLKSIZE=block- length 



indicates that carriage control 
characters are used for formatting 
purposes. 



indicates that machine code control 
characters are used. M may not be 
coded for ASCII records. 



indicates that the track overflow 
feature is to be used. This feature 
permits records to be written even 
though the block size exceeds the 
track size of a direct access device. 
This feature results in more efficient 
track utilization. 



Examples of RECFM are: 

RECFM=V 
RECFM=FBA 

The first example specifies variable- length 
records. The second example specifies 
fixed- length records which are blocked and 
written according to carriage control 
characters. 



LRECL is specified as: 

LRECL=r ecord- length 

where : 

record-length 

is a number indicating the length of 
the largest record to be found in the 
data set. The maximum value that may 
be specified is 32756. 

For fixed-length records, LRECL 
indicates the actual length of the record. 



block-length 

is a number indicating the length of 
the block of records. The number 
specified also determines the length 
of the buffer, i.e., the number of 
bytes of data transmitted between an 
I/O unit and main storage in one 
operation. The maximum value that may 
be specified is 32760. 

For fixed- length unblocked records, 
BLKSIZE is the same as the number specified 
in LRECL (LRECL may be omitted; if it is, 
the operating system determines the record 
length from BLKSIZE). For fixed-length 
blocked records, BLKSIZE is an integral 
multiple of LRECL. 

For variable-length unblocked records, 
BLKSIZE is equal to LRECL plus four for a 
block control word. A four-byte block 
control word precedes each block of 
variable-length records (whether the block 
contains a single unblocked record or a 
number of blocked records) and specifies 
the actual number of bytes contained in the 
block (including the length of the records, 
the segment control words preceding each 
record, and the block control word itself). 
For variable- length blocked records, data 
management will place records being written 
in an output block until there is no more 
room left for the next record and segment 
control word. It will then write the 
completed block (which does not have to be 
as large as BLKSIZE) and will start a new 
one with the new record. 

For undefined-length records, BLKSIZE 
should be specified to indicate the largest 
record that might be encountered. 

An example of BLKSIZE is: 

BLKSIZE=300 



50 



This example states that the block size is 
300 bytes. 



BUFNO is specified as: 
BUFNO=n 
where: 



indicates that the block prefix is 
four bytes long and that it is to be 
used to compute the block size. 
BUFOFF=L may be specified for both 
input and output data sets but only 
for variable-length records, that is, 
when RECFM=D (or RECFM=DB> is also 
specified. 



is a number indicating how many 
buffers are to be assigned to the data 
set. One, two, or three buffers may 
be assigned. (Three buffers may be 
specified only with asynchronous I/O. ) 
If the subparameter is omitted, two 
buffers are assigned. If the 
programmer specifies a number greater 
than three, three buffers are 
assigned. 



An example of BUFNO is : 

BUFNO=l 

This example states that only one buffer is 
to be assigned to the data set. 



BUFOFF is used with ASCII data sets to 
indicate the size of an optional block 
prefix. The block prefix is a field that, 
if specified, precedes each unblocked 
record or the first record in a block and 
contains information describing the record 
or block. It may be up to 99 bytes in 
length, and may be specified for 
fixed-length, undefined-length, and 
variable-length records. No use is made of 
the block prefix by IBM System/360 
Operating System except in certain cases 
where the information contained in it is 
used to determine the length of a block of 
variable-length records. 



BUFOFF is specified as: 



BUFOFF= 



where: 



is a number from to 99 indicating 
the size of the block prefix. 
BUFOFF=n may be specified only for 
input data sets; the operating system 
makes no use of the block prefix but 
skips the number of bytes specified 
before beginning record processing. 
If specified for output data sets, 
BUFOFF=n causes an error message to be 
written with abnormal termination 
resulting (unless the extended error 
handling facility is in force). 



The BUFOFF subparameter is optional; 
if not specified, BUFOFF defaults to 



An example of BUFOFF is : 



BUFOFF=40 

This example states that 40 bytes are to be 
skipped before record processing is to 
begin. 



The DEN and TRTCH subparameters define 
characteristics of data sets residing on 
magnetic tape. 

DEN indicates the recording density of a 
tape volume. It is specified as : 

DEN=density 

where : 

density 

is the number 0, 1, 2, or 3. The 
number indicates density of 200 bits 
per inch of tape (bpi) ; 1 indicates 
556 bpi; 2 8 00 bpi; and 3 1600 bpi. 

Data may be stored on seven-track tape or 
nine-track tape. Seven-track tape may be 
written 200 bpi, 556 bpi, or 800 bpi. 
Nine-track tape may be written 800 bpi or 
1600 bpi. DEN is optional; if it is not 
specified, 800 bpi is assumed for both 
seven-track and nine-track tape. 

An example of DEN is: 

DEN=3 

The example states that the data set has a 
density of 1600 bpi. 

TRTCH is used for seven-track tape to 
indicate the recording technigue to be 
used. 

TRTCH has the format: 



TRTCH= 



Using Job Control Statements 51 



where: 



PS 



indicates the data conversion feature. 
The data conversion feature converts 
binary data between seven-track tape 
and eight-bit main-storage. Because 
of the difference in the number of 
bits per character (seven-track tape 
has six data bits and one parity-check 
bit), four tape characters are stored 
as three main-storage bytes. 



indicates even parity. Parity is a 
technique that determines whether any 
bits were lost during data 
transmission by counting the number of 
bits in each character. The mode may 
require the parity check to be even or 

r\AA i 4-V>o ^nf ^nl + "a 1 no io r^/^A r~>a r 1 +■ \r . 



indicates data translation from BCD to 
EBCDIC. 



indicates physical sequential 
organization. PS is specified for 
direct access data sets that will oe 
processed only by FORTRAN programs. 



OPTCD indicates optional services to be 
performed by the control program. As 
applicable to a FORTRAN program, it is 
specified as: 



OPTCD= 



where : 



indicates an unlabeled ASCII data set. 
If an ASCII data set has been 
specified with a label ( LABEL= ( , AL) ) , 
this option need not be specified. 



ET 



indicates even parity and data 
translation. 



If this subparameter is not specified, 
the default value is odd parity with no 
conversion or translation. 



DSORG defines the organization of a 
direct-access data set. As applicable to a 
FORTRAN program, it is specified as: 



indicates chained scheduling. Chained 
scheduling is a technique whereby the 
control program receives several 
separate read or write operations as 
one continuous operation; in a program 
having extensive input/output 
operations, chained scheduling may 
result in a significant reduction in 
processing time, particularly when 
creating a FORTRAN DA data set. 



Examples of the DCB parameter are: 



DSORG= 



DA 



PS 



DCB= (RECFM=F, BLKSIZE=100, DEN=2 ) 
DCB=(RECFM=VB, LRECL=54, 

BLKSIZE=850, BUFN0=1) 



where: 



DA 



indicates direct access organization. 
DA should be specified for 
direct-access data sets that will be 
processed by non- FORTRAN programs; 
this specification causes a label to 
be created indicating that the data 
set has direct organization. 



The first example describes fixed-length 
unblocked records 100 bytes long on tape 
written in 800 bpi. The second example 
describes variable-length blocked records 
with a maximum record size of 50 bytes plus 
four for segment control word, a maximum 
block size (including record control words 
and block control word) of 850, and one 
buffer to transmit this data. 



52 



COMPILATION 



The FORTRAN IV (H Extended) compiler is a 
processing program that translates a 
FORTRAN IV source module into an object 
module. 

The EXEC statement calls the compiler by 
name, IFEAAB, in the PGM parameter, i.e., 

// EXEC PGM= IFEAAB 

The EXEC statement may also specify other 
parameters and compiler options. 



COMPILER OPTIONS 



Compiler options are specified in the PARM 
parameter of the EXEC statement. They 
increase the flexibility of the compiler. 
For example: 

• The SOURCE option lists the statements 
in the source module 

• The LIST option writes the object 
module 

• The MAP option writes a table of names 
used in the source module 

• The DECK option produces a card deck of 
the object module. 

All the options available are illustrated 

in Pi nnro T — Q nofanlt QDf 1QT! , arP 

indicated by an underscore and need never 
be specified explicitly. The default 
options shown are standard IBM defaults; 
when the compiler is installed, each 
installation may establish its own set of 
default options. 

Options may be coded in any order and 
may be separated by blanks or commas. As 
many as 100 characters may be coded in the 
PARM field. The options are enclosed in 
guotation marks except when the PARM field 
is continued onto a following card; the 
field must then be enclosed in parentheses 
rather than guotation marks, and each 
option containing a parenthesis must be 
enclosed in guotation marks. The following 
is an example of a continued PARM field: 

PARM=(NOSOURCE, 

•LINECOUNT(50) • ,LIST) 

For purposes of simplicity, the discussion 
below lists only one affirmative and 



negative form of each option. For examples 
of output that these options produce, see 
the chapter "Compiler Output. " 

S OURCE 

NOSOURCE 

indicates whether the source_mpdule 
listing is to be written. If SOURCE 
is specified, the listing is produced 
in the data set defined by the 
SYSPRINT DD statement. 

LINECOU NT( number) 

indicates the maximum number of lines 
to be assigned per page of the source 
listing. The number may be in the 
range 1 to 99. If the option is 
omitted, the compiler assumes 60. 

LIST 

NOLIST 

indicates whether the object_module 
listing is to be written. The object 
module listing consists of statements 
written in pseudo-assembler language 
format. If LIST is specified, the 
listing is produced in the data set 
defined by the SYSPRINT DD statement. 

OBJECT 

NOOBJECT 

indicates whether the object module 
(not the listing) is to be written. 
OBJECT must be specified if the 
linkage editor job step is to be 
called in the current job. If the 
object module is to be written, it is 
written in the data set defined by the 
SYSLIN DD statement, which defines 
primary input to the linkage editor 
job step. 

DECK 

NODE CK 

indicates whether the object module in 
card image form is to be produced in 
the data set specified by the SYSPUNCH 
DD statement. DECK is usually 
specified when the compilation step is 
not immediately followed by the 
linkage editor step; the deck is used 
to supply input to the linkage editor 
in a subseguent job. 

OPTIMIZE({0|1|2}) 

NOOPTIMIZE 

indicates what o ptimi zing level is to 
be in force. NOOPTIMIZE indicates 
that no optimization is to be 
performed, and is equivalent to the 
specification OPTIMIZE(O). 
OPTIMIZE (1) specifies that each source 



Compilation 53 



module is to be treated by the 
compiler as a single program loop and 
that the single loop is to be 
optimized with regard to register 
allocation and branching. OPTIMIZE(2) 
specifies that each source module is 
to be treated as a collection of 
program loops and that each loop is to 
be optimized with regard to register 
allocation, branching, common 
expression elimination, and 
replacement of redundant computations. 
Optimizing techniques are discussed in 
greater detail in the section 
"Programming Considerations." 



FORMAT 
NOFORMAT 



indicates whether a structured source 
module listing is to be written. A 
structured source module listing 
indicates loop structures and the 
logical continuity of a source 
program. This option is effective 
only when OPTIMIZE (2) is in effect, 
and a DD statement named SYSUT1 is 
present; the listing is written in the 
data set specified by the SYSPRINT DD 
statement. 



GOSTMT 
NOGOSTMT 



indicates whether internal sequence 
numbers (ISN) are to be generated for 
the calling sequence to subroutines 
for a traceback map. (A traceback map 
is a tool used in diagnosing execution 
errors; it is discussed in "Load 
Module Output.") 



MAP 
NOMAP 



indicates whether a table of names and 
statement labels used by the source 
program is to be written. If MAP is 
specified, the table is written in the 
data set specified by the SYSPRINT DD 
statement. 



XREF 
NOXREF 



indicates whether a cross reference 
listing of variables and labels used 
in the source program is to be 
written. If XREF is specified, ISNs 
are generated for each statement in 
which a variable or label is used. If 
XREF is specified, a DD statement 
named SYSUT2 must be supplied; the 
listing is written in the data set 
specified by the SYSPRINT DD 
statement. 



NAME (name) 

indicates the name to be given to the 
main sour ce p r ogram . The name may be 
from one to six characters. If NAME 
is not specified, the compiler assumes 
the name MAIN. 



BCD 

EBCDIC 

indicates whether the source_module is 
written in BCD (Binary Coded Decimal) 
or EBCDIC (Extended Binary Coded 
Decimal Interchange Code). If BCD and 
EBCDIC statements are intermixed in 
the source module, BCD should be 
specified. BCD characters are not 
supported by the compiler as print 
control characters or in literal data. 
For example, the carriage control 
character to specify same line 
printing, +, is specified as a 12-8-6 
punch in EBCDIC and as a 12 punch in 
BCD; the compiler recognizes only the 
EBCDIC code. Therefore, programs 
keypunched in BCD should be carefully 
screened for potential errors before 
job submission. 



SIZE 



MAX 

nnnnk 
indicates the amount of main storage 
to be allocated to the compilation 
step. The symbol nnnnK represents the 
number, multiplied by K (1024-bytes) , 
to be allocated. The number may range 
from 160 to 9999. 

If SIZE(MAX) is specified, or if 
the option is omitted, the compiler 
uses all available storage in the 
environment in which it is operating, 
except for approximately 3K bytes 
which are left for system routines. 
SIZE should only be specified to 
reduce the amount of storage required 
by FORTRAN in a multitasking 
environment. 



AUTODBL( value) 



calls the Automatic Precision Increase 
(API) fadility and indicates whether 
data item s are to be converted to 
higher precision. API provides an 
automatic means of converting single 
precision floating point calculations 
to double precision accuracy and 
double precision calculations to 
extended precision accuracy. The 
AUTODBL option indicates which 
particular data types are to be 
converted. The AUTODBL option is 
discussed in detail in the section 
"Automatic Precision Increase". 

If AUTODBL is omitted, no precision 
increase is performed. 



54 



ALC 

NOALC 

indicates whether data items are to be 
aligned on pr o per s torage boundaries . 
T+- is Q-f-i-^n used with ''"he A TT T'~' irvD L 
option to restore proper storage 
boundaries when a conversion is 
performed. ALC is discussed in detail 
in the section "Automatic Precision 
Increase. " 

ANSF 

NOAN SF 

indicates whether the compiler is to 
recognize only those library and 
built-in fun c tions specified by th e 
Ame rican National Standards Instit ute , 
(ANS), or the entire range of 
functions specified by IBM in the 
publication IBM System/ 3 60 and 
System/3 70 FO RTRAN IV Language , Order 
No. GC28-6515. If ANSF is specified, 
any function not supported by ANS is 
considered to be user-supplied. 



module. To change the options for any 
source module, the programmer precedes the 
source module with a card containing the 
characters *PROCESSb in columns 1 through 9 
followed by the options up to column 72, 
which must be left blank and which denotes 
the end of the +PROCESS card. 

An example of the * PROCESS card is: 

♦PROCESS LIST, MAP 



If succeeding source modules are not 
preceded by a +PROCESS card, options revert 
to those specified in the EXEC statement. 
Any option except SIZE may be specified on 
the ^PROCESS card. 



COMPILER DATA SETS 



FLAG ( I ) 

FLAG(E) 

FLAG ( S ) 

indicates the level of diagnostic 
messages to be printed . FLAG (I) 
indicates that information messages, 
warning messages (those generating a 
return code of 4) , error messages 
(those generating a return code of 8), 
and severe error messages (generating 
a return code of 12 or higher), are to 
be printed. FLAG(E) indicates that 
only error messages and severe error 
messages are to be printed. FLAG(S) 
indicates that only severe error 
messages are to be printed. 



DUMP 
NODUMP 



indicates whether the contents of 
registers, storage, and files 
associated with the compiler are to be 
printed if an abnormal termination 
occurs. If DUMP is specified, a DD 
statement named SYSUDUMP or SYSABEND 
must be supplied; the dump is written 
in the data set specified by the DD 
statement. 



Changing Program Options During a Batch 
Compilation 



A batch compilation permits the programmer 
to compile more than one source module in a 
single job. The PARM options specified in 
the EXEC statement apply to each of the 
source modules unless the programmer 
specifies different options for a source 



The compiler uses up to seven data sets, 

Table 1-7 lists the function, device 
types, and allowable device classes for 
each data set. Table 1-8 lists the DCB 
default values for data set 
characteristics. 



Data Sets Defined i n C ataloged Procedures 



If the programmer uses a cataloged 
procedure, he need not define the DD 
statements SYSPRINT, SYSPUNCH, SYSLIN, 
SYSUT1, and SYSUT2; these are defined in 
the cataloged procedure. 

SYSPRINT defines printed output. Such 
output may be directed to a tape, direct 
access device, or to a printer. To specify 
output to a printer, the DD statement is 
coded : 

//SYSPRINT DD SYSOUT=A 

SYSOUT is the disposition for system data 
sets, and A is the standard output class 
for a printer. 

SYSPUNCH defines punched output (output 
in card image format). Such output may be 
directed to a tape, direct access device, 
or to a card punch. To specify output to a 
card punch, the DD statement is coded: 

//SYSPUNCH DD SYSOUT=B 

B is the standard output class for a card 
punch. 



Compilation 55 



I COMPILER OPTIONS | 

,. T h 



Form 

_ _ J 


Abbreviated 
Form 

L 


SOURCE | NOSOURCE 


r 

S|NOS 


LINECOUNT ( number ) 1 


LC (number ) 


LISTINOLIST 




OBJECT | NOOBJECT 2 


OBJ | NOOBJ 


DECK | NODECK 




OPTIMIZEC {0|1|2}) 3 
NOOPTIMIZE 


OPT<{0|1|2}> 
NOOPT 


FORMAT | NOFORMAT 1 * 


FMT | NOFMT 


GOSTMT 1 N0G0STMT 5 




MAP | NOMAP 




XREF | NOXREF 




NAME ( name ) 6 




EBCDIC | BCD 


EB|BCD 


(MAX ) 
SIZE(< >) 
(nnnnK; 




AUTODBL( value) 


AD (value) 


ALC | NOALC 




ANSFINOANSF 




FLAG (I) |FLAG(E) |FLAG(S) 




DUMP | NODUMP 





J. 

Notes : 



^-Compiler also accepts the old form: 

LINECNT=XX 
2 Compiler also accepts the old form: 

LOAD | NOLOAD 
3 Compiler also accepts the old form: 

OPT=C0|l|2} 
"Compiler also accepts the old form: 

EDIT|NOEDIT 
5 Compiler also accepts the old form: 

ID | NO ID 
6 Compiler also accepts the old form: 

NAME=name 

Figure 1-9. Compiler Options 

SYSLIN defines the object module created 
by the compiler. The object module may be 
directed to a tape or direct access device. 
The following is a typical SYSLIN DD 
statement: 



//SYSLIN DD DSNAME=&6L0ADSET, 

// DISP= (MOD, PASS) ,UNIT=SYSSQ ( 

// SPACE=(U00, (200, 50) ) 

In this example, DSNAME=&6LOADSET specifies 
a temporary data set that is to contain the 
object module. DISP=( MOD, PASS) specifies 
that the data set is new or is to be 
modified (in the event of multiple 
compilations) and is to be passed to a 
succeeding job step, in this case the link 
edit step. UNIT=SYSSQ specifies that the 
data set is to reside in a sequential 
device class. SPACE=(400, (200, 50) ) 
specifies that space is to be allocated for 
records whose average block length is 400 
bytes; space is allocated initially for 200 
such blocks and additional space is 
allocated as necessary for 50 more such 
blocks. 

SYSUT1 and SYSUT2 define utility data 
sets used by the compiler. SYSUT1 is used 
if the compiler option FORMAT (structured 
source listing) is requested. SYSUT2 is 
used if the compiler option XREF (produce 
cross reference listing) is requested. 
Both data sets may reside on a tape or 
direct access device. The following is a 
typical DD statement for a utility data 
set: 

//SYSUT1 DD UNIT=SYSSQ,SPACE=(3465, (10,10) > 

In this example, UNIT=SYSSQ specifies that 
the data set is to reside in the sequential 
device class SYSSQ. SPACE=(3465, (10, 10) ) 
specifies that space is to be allocated for 
records whose average block length is 1050 
bytes; space is allocated initially for 10 
such blocks, and additional space is 
allocated as necessary for 10 more such 
blocks. 



Data Sets That Must Be Defined by the 
Programmer 



Cataloged procedures do not supply the DD 
statements SYSIN, SYSUDUMP, and SYSABEND; 
the programmer must define these, as 
required, when he submits a program to be 
compiled. 

SYSIN defines the source module. The 
source module may reside on a tape, on a 
direct-access device, or on cards. To 
specify a source module in the input 
stream, the DD statement is coded: 

//SYSIN DD * 

The asterisk indicates that the source 
module statements physically follow the 
SYSIN DD* statement. 



56 



Table 1-7. Compiler Data Sets. 



r i 
j ddnanie 


r __ T T ___ T ___ 1 

| | | Defined in Cataloged! 

j | Applicable j Procedures Calling \ 

Function j Device Types | Device Class j the Compiler | 

L J_ X J_ J 


r T T T T 1 

| SYSIN |Reading input source |Card reader |Input stream (defined| No | 
| (module j Magnetic tape| as DD * or DD DATA) | j 
j | | Direct access |SYSSQ j | 


| SYSPRINT 


Writing listings, 
storage maps, mes- 
sages 


Printer |A j Yes | 
Magnetic tape (SYSSQ j | 
Direct access | j j 


| SYSPUNCH 


Punching the object 
module deck 


Card punch 1 j B j Yes | 

Magnetic tapejSYSCP | | 

Direct access j SYSSQ I j 

| SYSDA 1 | 


| SYS LIN 


Creating an object 
module data set as 
compiler output and 
linkage editor input 


Direct access | SYSDA j Yes | 
Magnetic tape | SYSSQ j | 
Card punch 1 | SYSCP | | 


| SYSUT1 


Work data set for 
structured source 
listing; required if 
compiler option EDIT 
is requested 


Magnetic tape | SYSSQ | Yes | 
Direct access j j J 


| SYSUT2 


Work data set for 
compiler cross 
reference listing; 
required if compiler 
option XREF is re- 
quested 


Magnetic tape | SYSSQ j Yes | 
Direct access | j j 


| SYSUDUMP 

1 or 

j SYSABEND 


Writing dump in event 
of abnormal termina- 
tion 


Printer |A j No | 
Magnetic tape | SYSSQ | | 
Direct accessj j | 



|. X X X 

I ^SYSPUNCH and SYSLIN may not be directed to the same card punch. 



Table 1-8. DCB Default Values for Compiler 
Data Sets 

r T T T T 1 

jddname | LRECL |RECFM|BLKSIZE| BUFNO | 

2 
2 
2 
2 
2 
2 



SYSIN | 


80 


FB 


80 | 


SYSPRINT | 


137 


VBA 


141 | 


SYSLIN | 


80 


FB 


3200 | 


SYSPUNCH | 


80 


FB 


3440 | 


SYSUT1 | 


105 


FB 


3465 1 | 


SYSUT2 | 


1024- 


FB 


1024- J 




4096 2 




4096 1 | 



^-This value is fixed by the compiler and 
may not be overridden. (Values for 
other entries may be overridden through 
the DCB parameter in the DD statement. ) 

2 The value is within this range and the 
actual value is calculated during 
compiler execution. 



SYSUDUMP or SYSABEND define data sets on 
which abnormal termination dumps may be 
written if the DUMP compiler option has 
been specified. SYSUDUMP is requested when 
the user wants to display the problem 
program area in the event of an abnormal 
termination. SYSABEND is requested when 
the user wants to display the system 
nucleus and trace table in addition to the 
problem program area. Abnormal termination 
data sets may be directed to tape, direct 
access devices, or to a printer. To 
specify the data set to a printer, the DD 
statement is coded: 



//SYSUDUMP DD SYSOUT=A 



or 



//SYSABEND DD SYSOUT=A 



Compilation 57 



LINKAGE EDITOR AND LOADER 



The linkage editor and the loader are two 
of the processing programs in the operating 
system. They both perform the link edit 
function, i.e., combining the object module 
with other modules to form one executable 
load module. They differ in the way they 
store the load module. The linkage editor 
places the load module into a library, 
where it is called for execution by another 
job step; the loader places the load module 
directly into storage for execution in the 
same job step. 



LINK EDIT JOB STEP 



The EXEC statement calls the linkage editor 
by name, IEWL, in the PGM parameter, i.e., 

// EXEC PGM=IEWL 

The EXEC statement may also specify other 
parameters and linkage editor options. 



LINKAGE EDITOR OPTIONS 



CHOOSING THE PROPER LINKAGE PROGRAM 



The choice of the proper linkage program 
depends upon the facilities required. The 
linkage editor provides the following 
facilities: 

1. The overlay feature. The overlay 
feature separates a program into two 
or more segments that do not have to 
be in main storage at the same time, 
thereby reducing storage size 
requirements for large programs. 

2. Control statements to provide 
additional processing flexibility. 
Linkage editor control statements 
define additional libraries available 
to the linkage editor, define the 
structure of segments of a program, 
and serve other uses. 

3. Placement of the load module into a 
library for execution at a later time. 

The loader is the more efficient program 
when: 

1. a small load module, not requiring the 
use of overlay, is to be executed, 

2. no linkage editor control statements 
are needed, and 

3. the load module is to be executed 
immediately. 



Linkage editor options increase the 
flexibility of the linkage editor. At the 
time the operating system is generated, 
each installation chooses its set of 
default options. At execution time, the 
programmer may specify other options 
through the EXEC statement PARM parameter. 
Options available are illustrated in Figure 
1-10. Options may appear in any order. 
For examples of output that these options 
produce, see the section "Linkage Editor 
and Loader Output . " 



MAP 
XREF 



LET 



indicates that a map of the load 
module is to be produced, showing the 
JkPgation and l eng t h of main programs 
and sub p r ogr ams. The map is produced 
in the data set defined by the 
SYSPRINT DD statement. XREF indicates 
that a crgssref erence listing is also 
to be produced. If neither option is 
specified, no map or cross-reference 
listing is produced. 



indicates that the linkage editor is 
to mark the load module executable 
even though abnormal conditions, which 
could cause execution to fail, have 
been detected. The LET option is 
useful in testing segments of a large 
program that refer to segments not yet 
coded; as long as the calls to absent 
segments are not executed, the user 
can still test the finished segments. 



PARM=' 



MAP 
XREF 



, [LET] , [NCAL] 



, [LIST] 



, [OVLY] ' 



L J 



Figure 1-10. Linkage Editor Options 



58 



NCAL 



LIST 



indicates that the linkage editor is 
to call no system libraries to resolve 
external references. (The SYSLIB DD 
statement, which defines system 
libraries, need not be submitted. ) 
The load module is marked executable 
even though references to other 
programs may have been detected. 



indicates that any linkage editor 
control statements are to be listed in 
the data set defined by the SYSPRINT 
DD statement. 



OVLY 



be in the format of an overlay 
program , i.e., segments of the program 
may share the same storage area at 
different times during processing. 
Overlay programs are described in 
detail in the section "Linkage Editor 
Overlay Feature. " 



LINKAGE EDITOR DATA SETS 



SYSLIB defines the system library, 
SYS1. FORTLIB, from which IBM-supplied 
FORTRAN subroutines may be obtained by the 
linkage editor to resolve references made 
by the object module to other programs 
(such references are called external- 
referenc es) . SYSLIB is specified if there 
is a possibility that the compiler may have 
generated calls to any FORTRAN subroutine. 
SYS1. FORTLIB exists prior to the job and 
may be called simply by name. To specify 
the library, the DD statement is coded: 

//SYSLIB DD DSNAME=SYS1. FORTLIB, DISP=SHR 

In this example, DISP=SHR is coded to 
permit other jobs to have access to the 

progress. If the NCAL option is specified, 
the SYSLIB DD statement is not required. 

SYSLMOD defines the load module created 
by the link edit job step. The load module 
may be directed only to a direct access 
device and must be stored in a library as a 
named member. The library may be the 
system library, SYSl. LINKLIB, a temporary 
library, or a private library. The 
following is a typical SYSLMOD DD 
statement : 



The linkage editor normally uses five data 
sets; others may be necessary if secondary 
input is specified. 

Table 1-9 lists the function, device 
types, and allowable device classes for 
each data set. 



Data Sets Defined in Cataloged Procedures 



Cataloged procedures calling the linkage 
editor contain the DD statements SYSLIN, 
SYSLIB, SYSLMOD, SYSPRINT, and SYSUTl. 
(Note that the SYSUTl DD statement for the 
linkage editor should not be confused with 
the SYSUTl DD statement used in the compile 
job step. ) 



//SYSLMOD DD DSNAME=SGOSET(MAIN> , 

// UNIT=SYSDA, DISP= ( , PASS ) , 

// SPACE=(3072, (30,10,1>,RLSE) 

In this example, DSNAME=SGOSET specifies a 
temporary library. MAIN specifies the 
member name of the load module. UNIT=SYSDA 
specifies that the data set is to reside in 
a direct access device class, DISP=(,PASS) 
specifies that the data set is new (by 
default) and that it is to be passed to a 
later job step. SPACE=(3072, (30, 10, 1) , RLSE) 
allocates space for 3 record blocks, whose 
size is 3072 bytes, allocates space for 10 
additional blocks as necessary, allocates 1 
block of 256 bytes for the directory, and 
specifies that unused space may be released 
at the end of the step. 

The following example indicates how a 
programmer may store the load module into a 
private library: 



SYSLIN defines the object module used as 
input to the linkage editor. The following 
is a linkage editor SYSLIN DD statement 
that is the counterpart to the compiler 
SYSLIN DD statement illustrated in the 
section "Compilation": 

//SYSLIN DD DSNAME=&LOADSET, 

// UNIT=SYSSQ,DISP= (OLD, DELETE) 

In this example, DISP= (OLD, DELETE) 
specifies that the data set existed prior 
to this job step and that it is to be 
deleted at the end of the step. 



//SYSLMOD DD DSNAME=USERLIB (PROGl) , 
// UNIT=SYSSQ, DISP=(,CATLG), 

// SPACE=(TRK, (50,30,3) , 

// VOLUME=SER=34345 

In this example, USERLIB specifies the name 
of the library. PROGl the member name of 
the load module. UNIT=SYSSQ specifies that 
the library (or data set) is to reside in a 
sequential device class. DISP=(, CATLG) 
specifies a new data set that is to be 
cataloged. SPACE allocates 50 tracks 
initially, 30 tracks if needed 
subsequently, and 3 blocks of 256 bytes for 



Linkage Editor and Loader 59 



the directory. VOLUME specifies the 
specific volume which is to hold the data 
set. 

To execute the load module PR0G1 in a 
later job, the programmer must submit job 
control statements containing the following 
minimum information: 



In this example, DSNAME=S SYSUTl specifies a 
temporary data set. UNIT=SYSDA specifies 
that the data set resides in a direct 
access device class. SPACE allocates space 
to the data set. SEP=SYSLMOD specifies 
that this data set is not to use the same 
channel as the data set defined in the 
SYSLMOD DD statement. 



//jobname JOB 

//JOBLIB DD DSNAME=USERLIB,DISP= (OLD, KEEP) 

// EXEC PGM=PR0G1 

The DD statement defining a private library 
must be named JOBLIB and must follow the 
JOB statement and precede any EXEC 
statements. It makes the private library 
available. The EXEC statement names the 
program to be executed. These statements 
cause the operating system to search the 
private library to locate the program as an 
executable load module. 

SYSPRINT defines printed output. As in 
the compiler step, such output may be 
directed to a tape, a direct access device, 
or to a printer. 

SYSUT1 defines a utility data set used 
by the linkage editor. This data set may 
reside only in a direct access device 
class. The following is a typical SYSUTl 
DD statement: 

//SYSUTl DD DSNAME= & SYSUTl ,UNIT=SYSDA, 
// SPACE= (1024, (200,20)), 

// SEP=SYSLMOD 



Data Sets That Must Be Defined by the 
Programmer 



There are two kinds of input to the linkage 
editor: primary and secondary. If any 
secondary input is to be submitted, the 
programmer must define it; cataloged 
procedures do not supply DD statements for 
secondary input. 



Pri mary In put 



Primary input is the data set defined in 
the SYSLIN DD statement. Normally, this 
data set consists of the output from a 
previous compilation job step, but primary 
input may also be linkage editor control 
statements (discussed under "Linkage Editor 
Control Statements"). Primary input may 
reside on tape, direct access, or cards. 



Table 1-9. Linkage Editor Data Sets 
r t T— 



T 



ddname 

_ j 


Function 

l - -i 


Device Type 

L J 


Applicable | 
Device Class j 

L ± 


Defined in 
Cataloged 
Procedures 
Calling the 
Linkage Editor 


1 
SYSLIN 


r 1 
Primary input data, 
normally output of 
the compiler 


r 1 

Direct access 
Magnetic tape 
Card reader 


SYSDA 
SYSSQ 
input 
as DD 


stream ( defined j 
* or DD DATA) j 


Yes 


SYS LIB 


Automatic call library 
(SYS1.FORTLIB) 


Direct access 


SYSDA 






Yes 


SYSLMOD 


Link edit output 
(load module input) 


Direct access 


SYSDA 






Yes 


SYSPRINT 


Writing listings, 
messages 


Printer 
Magnetic tape 
Direct access 


A 
SYSSQ 






Yes 


SYSUTl 


Work data set 


Direct access 


SYSDA 






Yes 


user- 
defined 


Additional libraries 
and object modules 


Direct access 
Magnetic tape 


SYSDA 
SYSSQ 






No 



L JL JL J. J. J 



60 



Secondary Input 



Secondary input consists of modules that 
are not Dart of the orimarv in^ut data set 
but are to be included in the load module. 
The linkage editor uses secondary input to 
resolve external references between the 
primary input and other programs which it 
calls. Secondary input may be in the 
following forms: 



1. Object modules specified by the user. 
These modules may be either sequential 
data sets or members of a library. 



2. Load modules specified by the user. 
These modules must be members of a 
library. They may contain linkage 
editor control statements. 



3. The automatic call library » 

SYS1. FORTLIB. This is the data set 
defined in the SYSLIB DD statement. 
SYS1. FORTLIB contains the FORTRAN 
library subprograms as its members. 
The linkage editor uses this library 
if unresolved references remain after 
other input has been processed. 



INCLUDE Statement : The INCLUDE statement 
specifies additional programs to be 
included as part of the load module. Its 
format is: 



r t 

| Operation | Operand 



h 



INCLUDE | ddname [ (member -name 

| [ , member- name] . . . ) ] 
| [ , ddname [ (member-name 
| [ , member-name] ...)]...] 

x 



Each ddname indicates the name of a DD 
statement specifying a library or a 
sequential data set, and each member-name 
is the name of the member to be included. 
When sequential data sets (not members) are 
specified, member-name is omitted. 

The following is an example of the 
INCLUDE control statement and its 
corresponding DD statement : 

//LIB1 DD DSNAME=MYLIB,DISP=OLD 
//SYS LIN DD * 
INCLUDE LIBKPR0G1) 

LIBRARY Statement: The LIBRARY statement 
specifies additional libraries to be 
searched for object modules to be included 
in the load module. 



The user defines secondary input in a 
linkage editor control statement and a DD 
statement. 



Linkage Editor Control Statements 



The LIBRARY statement differs from the 
INCLUDE statement in that libraries 
specified in the LIBRARY statement are not 
searched until all other references (except 
those reserved for the automatic call 
library) are completed by the linkage 
editor. A module specified by an INCLUDE 
statement is included immediately. 

The format of the LIBRARY statement is: 



Linkage editor control statements specify 
an operation and one or more operands. 



The first column of a control statement 
must be left blank. The operation field 
begins in column 2 and specifies the name 
of the operation to be performed. The 
operand field must be separated from the 
operation field by at least one blank. The 
operand field specifies one or more 
operands separated by commas. No embedded 
blanks may appear in the field. Linkage 
editor control statements may be placed 
before, between, or after either modules or 
other control statements in primary or 
secondary input data sets. 

The INCLUDE and LIBRARY control 
statements specify secondary input. 



r t n 

| Opera ti on | Ope rand j 

j. + ., 

| LIBRARY | ddname (member-name | 

| j [ , member-name] . . . ) | 

j j [, ddname (member-name | 
j | [, member-name] ...)]... ] | 
L j. J 



Each ddname indicates the name of a DD 
statement specifying a library, and each 
member-name is the name of a member of the 
library. 

The following is an example of the 
LIBRARY control statement and its 
corresponding DD statement: 

//LIB2 DD DSNAME=ADDLIB, DISP=OLD 
//SYS LIN DD * 
LIBRARY LIB2(ADD1,ADD2) 



Linkage Editor and Loader 61 



Figure I- 11 illustrates the use of 
linkage editor control statements. STEP1, 
STEP2, and STEP3 are compile job steps. 
STEPl compiles a main program, MAIN, and 
places the object module in a sequential 
data set called &6G0FILE. STEP2 and STEP3 
compile subprograms SUBl and SUB2 and place 
the object modules in separate sequential 
data sets. 



STEPU is the link edit job step. It 
uses the 6SG0FILE data set as primary 
input. The compiled subprograms are used 
as secondary input through the INCLUDE 
statements and the DD statements named DDl 
and DD2. An additional data set, defined 
in the LIBRARY statement and in the DD 
statement named ADDLIB, is to be used if 
external references are not resolved among 
the three object modules. Note that the 
INCLUDE and LIBRARY statements are entered 
through the input job stream with a DD * 
statement. 

After link edit processing, the load 
module CALC is stored as a member of the 
load module library PROGLIB. CALC contains 
the main program, the two subprograms, and, 
possibly, routines from the user library 
MYLIB and the system library SYSl. FORTLIB. 



IDENTIFY Stat eme nt : For a description of 
the IDENTIFY statement, see the OS/VS 
linkage editor and loader publication 
listed in the Preface. 



ORDERING AND PAGE-ALIGNING PROGRAM UNITS 
UNDER OS/VS 



Under the VS control programs, linkage 
editor control statements may be used to 
specify the sequence of FORTRAN program 
units in the output load module and to 
specify their alignment on page boundaries. 
Such ordering and alignment can be used to 
effect a lower paging rate and thus make 
more efficient use of real storage. 



ORDER Statement : The ORDER statement 
indicates the sequence in which program 
units are to appear in the output load 
module. The program units appear in the 
sequence in which they are specified on the 
ORDER statement. When multiple ORDER 
statements are used, their sequence further 
determines the sequence of program units in 
the output load module; those named on the 
first statement appear first, and so forth. 

The format of the ORDER statement is: 



r t 1 

| Operation | Operand | 

I. + ^ 

| ORDER |name[(P)] , name [<P>] ... | 

L J. J 

where : 



name 



(P) 



is the name of a FORTRAN main program, 
subprogram, or COMMON block 



indicates that the starting address of 
the program of the program unit is to 
be on a page boundary within the load 
module. The program units are aligned 
on 4K page boundaries unless the 
ALIGN2 attribute is specified on the 
EXEC statement. (Page boundary 
alignment in the executing module can 
only occur when the operating system 
supervisor includes support for fetch 
on a page boundary. This support is 
available only with VS2. ) 

An ORDER statement may be placed before, 
between, or after object modules or other 
control statements. 

PAGE Statement : The PAGE statement, like 
the (P) operand of the ORDER statement, 
aligns a program unit on a UK page boundary 
in the output load module. If the ALIGN 2 
attribute is specified on the EXEC 
statement for the linkage editor job step, 
use of the PAGE statement aligns the 
specified program units on 2K page 
boundaries within the load module. (As 
with the (P) operand of the ORDER 
statement, page boundary alignment in the 
executing module can only occur when the 
operating system supervisor includes 
support for fetch on a page boundary. This 
support is available only with VS2. ) 

The format of the PAGE statement is: 

r t 1 

| Operation | Operand | 

|. + j 

| PAGE | name [ , name] ... | 

L J. J 

where : 

name 

is the name of a FORTRAN main program, 
subprogram or COMMON block. 

The PAGE statement may be placed before, 
between, or after object modules or other 
control statement. 

In the example shown in Figure 1-10.1., 
the program units RAREUSE and MAINRT are 
aligned on 2K page boundaries by PAGE and 
ORDER control statements used with the 



62 



INPUT MODULE 
MAINROOT 



//LKED EXEC PGM= IEWL, PARM= ■ ALIGN2 ■ 



OUTPUT LOAD MODULE 

MAINROOT 
OK r t 



SBPRGA 



MAINRT 



I- \ 

| RAREUSE | 

I- "I 

| SUBPRG1 | 
f \ 

! ! 

I I 

j £sO\LT<JM j 



J. 1 

I I 

I I 

I MAINRT | 

I I 

I J 



//SYSLMOD 
//SYSLIN 
PAGE 
ORDER 
INCLUDE 
/* 



DD DSNAME=OWNLIB, . . . 

DD * 

RAREUSE 

MAINRT (P) , SBPRGA, SUBPRG1 

SYSLMOD ( MAINROOT ) 



2K \- -I 



SUBPRGA 



j. A 

SUBPRG1 
4K h -j 

6K I- -I 

RAREUSE 

h "I 



BOTTOM 



L j 

L J 

Figure 1-10.1. Ordering and Aligning Program Units on Page Boundaries 



ALIGN2 attribute. Program units SBPRGA and 
SUBPRG1 are sequenced by the ORDER control 
statement. Assume that each program unit 
is 2K in length except for SUBPPG1 and 
RAREUSE. 

The linkage editor places the program 
units MAINRT and RAREUSE on 2K page 
boundaries because ALIGN2 is specified in 
the EXEC statement. Program units MAINRT, 
SBPRGA, and SUBPRG1 are sequenced as 
specified in the ORDER statement. RAREUSE, 
while placed on a 2K page boundary, appears 
after the program units specified in the 
ORDER statement because it was not 
included. The program unit BOTTOM comes 
after RAREUSE because it appeared after 
RAREUSE in the input module. 



SYSTEM LOADER 



The loader combines into one job step the 
functions of link editing and load module 
execution. The loader combines the object 
module with other modules to form one 
executable load module. It places the load 
module directly into main storage and then 
executes it. By placing the load module 
directly into main storage, the loader 
eliminates the need for writing and then 
reading the SYSLMOD data set. The EXEC 
statement identifies the loader by either 



of its names, IEWLDRGO or LOADER, in the 
PGM parameter, i.e., 

//EXEC PGM=LOADER 

The EXEC statement may also specify 
other parameters and loader options. 



LOADER OPTIONS 



Loader options increase the flexibility of 
the loader. At the time the operating 
system is generated, each installation 
chooses its set of default options. At 
execution time, the programmer may specify 
other options through the EXEC statement 
PARM parameter. Options available are 
illustrated in Figure 1-12. Options may be 
coded in any order. 



MAP 
NOMAP 



indicates whether a map of the loaded 
program is to be produced, listing 
external names and absolute storage 
addresses. 



LET 
NOLET 



indicates whether the loader is to 
mark the load module executable even 



Linkage Editor and Loader 63 



CALL 
NCAL 



though abnormal conditions, which 
could cause execution to fail, have 
been detected. 



indicates whether the loader is to 
call a system library to resolve 
external references. If the library 
is to be called, the SYSLIB DD 
statement must be submitted. 



SIZE=nnnnn 

SIZE indicates the amount of storage , 
in bytes, that is to be al located to 
loader processing. The size of the 
load module must be included in this 
number. If the option is not 
specified, the default size, 100K, is 
assumed. 



Step 4 



//JOBX 
//STEP1 



JOB 
EXEC 



Step 1 (//SYSLIN DD 
V/SYSIN DD 



PGM=IFEAAB, PARM=' NAME (MAIN) , LOAD' 



DSNAME=SSGOFILE, DISP= ( , PASS) , UNIT=SYSSQ 



* 

r 1 

| Source module for MAIN | 
l J 



V* 

///STEP2 EXEC 



Step 2 ///SYSLIN DD 
\//SYSIN DD 



PGM=IFEAAB, PARM= ■ NAME ( SUB1 ) , LOAD ' 



DSNAME=S8SUBPR0G1,DISP=(,PASS),UNIT=SYSSQ 

* 



r 1 

| Source module for SUB1| 
i j 



'//STEP3 EXEC 



Step 3 J//SYSLIN DD 
\//SYSIN DD 



PGM=IFEAAB, PARM= • NAME (SUB2 ) , LOAD ' 



DSNAME=6SSUBPROG2, DISP=( , PASS) , UNIT=SYSSQ 

* 



r 1 

| Source module for SUB2| 
l J 



///STEPU EXEC 



PGM=IEWL 



//SYSLIB 

1//SYSLM0D 

//ADDLIB 

V/DD1 

\//DD2 

J//SYSLIN 

I// 

INCLUDE 
INCLUDE 
LIBRARY 

V* 
// 



DD 

DD 

DD 

DD 

DD 

DD 

DD 

DD1 

DD2 

ADDLIB (X,Y, Z) 



DSNAME=SYS1. FORTLIB, DISP=SHR 
DSNAME=PROGLIB(CALC) , UNIT=SYSDA 
DSNAME=MYLIB, DISP=OLD 
DSNAME=*. STEP2. SYSLIN, DISP=OLD 
DSNAME=*. STEP3. SYSLIN, DISP=OLD 
DSNAME=*. STEP1. SYSLIN, DISP=OLD 
* 



Figure I -11. Linkage Editor Processing 



64 



PARM=' 



MAP 




"RES " 




[CALL! 




"LET " 


NOMAP 


i 


NORES 


t 


NCAL 


i 


NOLET 



, [siZE=nnnnn] , [EP=name] , 



PRINT 



NOPRINT 



Figure 1-12. Loader Options 



EP=name 

indicates the name that is to be the 
entry point of the program being 
loaded. 

PRINT 

NOPRINT 

indicates whether loader mes sages are 
to be produced. Messages are produced 
in the data set defined by the SYSLOUT 
DD statement. 

RES 

NORES 

indicates whether, in an MVT 
environment, the link pack area g ueue 
is to be searched to resolve external 
references. The link pack is an area 
of storage that contains a number of 
modules needed for job processing. If 
RES is specified, the link pack area 
gueue is searched prior to any search 
of the SYSLIB data set. 



LOADER DATA SETS 



The loader normally uses six data sets; 
other data sets may be defined to describe 
libraries, loader output, and load module 
data sets. 



SYSLIB defines the system library, 
SYS1. FORTLIB, that is to be searched to 
resolve external references made by the 
input data set. The SYSLIB DD statement 
may be coded as follows: 

//SYSLIB DD DSNAME=SYS1. FORTLIB, DISP=SHR 

SYSLIB is not reguired if the NCAL loader 
option is specified. 

SYSLOUT defines the output data set to 
store the loader map. A printed listing is 
obtained if SYSLOUT is allocated to a 
printer device class, as follows: 

//SYSLOUT DD SYSOUT=A 

SYSLOUT is not reguired if the NOMAP and 
NOPRINT options are specified. 

FT05F001 defines the input data set to 
the load module. The function of this 
ddname is to associate the system input 
unit to FORTRAN READ statements having 5 as 
the data set reference number. 

Since cataloged procedures may not 
contain DD * statements, FT05F001 defers 
data set definition to the SYSIN DD 
statement, which the programmer must 
supply. The following FT05F001 DD 
statement appears in cataloged procedures: 



TaKio t_iq ^ists ■'"he function device 
types, and allowable device classes for 
each data set. 



Data Sets Defined in Catal o ged Procedures 



/ /"cm a c T?r\ r» -i 



UUHrtl'li-OIOlW 



The programmer completes card input 
definition by supplying a SYSIN DD 
statement as follows: 

//GO. SYSIN DD * 



Cataloged procedures calling the loader 
contain the DD statements SY3LIN, SYSLIB, 
SYSLOUT, FT05F001, FT06F001, and FT07F001. 

SYSLIN defines the object module that is 
primary input to the loader. Normally this 
data set consists of the output from a 
previous compile job step, but it may also 
be an object module from a partitioned data 
set. Input may reside on a tape, a direct 
access device, or on cards. The following 
is the loader SYSLIN DD statement 
corresponding to the compiler SYSLIN DD 
statement illustrated in the section 
"Compilation. " 

//SYSLIN DD DSNAME= 6 6 LOADS ET, 
// DISP=( OLD, DELETE) 



GO identifies card input with the GO step 
in cataloged procedures. 

FT06F001 defines the system printer 
unit. The function of this ddname is to 
associate the system printer to FORTRAN 
WRITE statements having 6 as the data set 
reference number. It is defined as 
follows : 

//FT06F001 DD SYSOUT=A 

FT07F001 defines the system card punch 
unit. The function of this ddname is to 
associate the card punch to FORTRAN WRITE 
statements having 7 as the data set 
reference number. It is defined as 
follows : 



Linkage Editor and Loader 65 



//FT07F001 DD SYSOUT=B 



Data Sets That Must be Defined by the 
Programmer 



messages. Output may be directed to a 
tape, a direct access device, or to a 
printer. To direct output to a printer, 
SYSPRINT is coded: 



//SYSPRINT DD SYSOUT=A 



The programmer must define the SYSIN DD 
statement to complete the description of 
the input data set, and the SYSPRINT DD 
statement. 

SYSPRINT defines system printed output, 
such as allocation and job control 



The programmer may also define other data 
sets as required by the load module 
execution function. See the section "Load 
Module Execution" for a discussion of these 
data sets. 



Table 1-10. Loader Data Sets, 
r t 



ddname 


Function 

L _ _ _ J 


Device Type 

1- -1 


Applicable 
Device Class 


_i 


Defined in 
Cataloged 
Procedures 
Calling the 
Loader 


SYS LIN 


Input data to linkage 
function, normally 
output of the compiler 


Direct access 
Magnetic tape 
Card reader 


SYSDA 
SYSSQ 
Input 
as DD 


stream 
*) 


(definedj 


Yes 


SYSLIB 


Automatic call 

library 

(SYS1.F0RTLIB) 


Direct access 


SYSDA 






Yes 


SYSLOUT 


Writing listings 


Printer 
Magnetic tape 
Direct access 


A 
SYSSQ 






Yes 


SYSPRINT 


Writing messages 


Printer 
Magnetic tape 
Direct access 


A 
SYSSQ 






No 


SYSIN 


Input data to load 
module function 


Card reader 

Magnetic tape 
Direct access 


Input 
as DD 
SYSSQ 
SYSDA 


stream 
*) 


( defined | 


No 


FT05F001 


Primary input data 
to be processed by 
the load module 


Card reader 

Magnetic tape 
Direct access 


Input 
as DD 
SYSSQ 
SYSDA 


stream 
* or DE 


(definedj 
DATA) | 


Yes 


FT06F001 


Printed output data 


Printer 


A 






Yes 


FT07F001 


Punched output data 


Card punch 


B 






Yes 


FTnnFnnn* 


User-defined data set 


Unit record 
Magnetic tape 
Direct access 


SYSSQ 
SYSDA 


A,B 




No 



t. j. j. ± x .! 

| *nn and nnn cannot be set to 0. | 

L J 



66 



LOAD MODULE EXECUTION 



The load module execution job step executes 
a load module. The load module may be 
passed directly from a preceding link edit 
job step, it may be called from a library 
of programs, or it may form part of the 
loader job step. If passed from the link 
edit job step, the load module is called in 
the PGM parameter of the EXEC statement, 
i.e. , 



function, device types, and allowable 
device classes for each data set. 



Data Sets De fined in C ata loged Procedures 



// EXEC PGM=*.LKED.SYSLMOD 

This statement defines the load module as 
consisting of the data set described in the 
SYSLMOD DD statement in the link edit 
(LKED) job step of the current job. 

If the load module is called from a 
library, it is called by name, as any 
program, in the PGM parameter, i.e., 

// EXEC PGM=MATRIX 

The library in which the load module 
resides must also be made available to the 
operating system via a DD statement. A 
load module may reside on the system 
library, SYSl. LINKLIB, or on a private 
library. A private library is defined in a 
JOBLIB or STEPLIB DD statement. For 
example, if the load module MATRIX is a 
member of a private library named MATH, the 
user may supply the following DD statement: 

//JOBLIB DD DSNAME=MATH,DISP= (OLD, PASS) 

The JOBLIB DD statement must appear after 
the JOB statement and before any other 
control statement. This placement ensures 
that the private library is kept available 
for all steps within the job. 

If the load module is executed as part 
of the loader, it is not defined in an EXEC 
statement. The loader combines the link 
editing and load module execution into one 
job step. 



LOAD MODULE DATA SETS 



The load module execution job step may use 
many data sets. Table 1-11 lists the 



Cataloged procedures calling the execution 
job step contain the DD statements 
FT05F001, FT06F001, and FT07F001. 

FT05F001 defines the input data set. 
The programmer codes 5 as the data set 
reference number in any FORTRAN READ 
statement that reads card input. Since 
cataloged procedures may not contain DD * 
statements, FT05F001 is coded to defer data 
set definition to the SYSIN DD statement, 
which the programmer must supply. The 
following FT05F001 DD statement appears in 
cataloged procedures : 

//FT05F001 DD DDNAME=SYSIN 

The programmer completes card input 
definition by supplying a SYSIN DD 
statement as follows: 

//GO. SYSIN DD * 

GO identifies card input with the GO step 
in cataloged procedures. 



FT06F001 defines a printer data set. 
The programmer codes 6 as the data set 
reference number in any WRITE statement 
writing data to be printed. The following 
FT06F001 DD statement appears in cataloged 
procedures : 

//FT06F001 DD SYSOUT=A 



FT07F001 defines a card punch data set. 
The programmer codes 7 as the data set 
reference number in any WRITE statement 
writing data to be punched. The following 
FT07F001 DD statement appears in cataloged 
procedures : 

//FT07F001 DD SYSOUT=B 



Load Module Execution 67 



Table 1-11. Load Module Data Sets 



r T T T 

1 J | (Applicable 
jddname j Function j Device Type | Device Clas 

L _ ^ -L J- 


T 

| Defined in Cataloged 
| Procedures Calling the 
s|Load Module 
j. _ _ __ 


r t 
|FT05F001 


r i 
Input data to the 
load module 


r t 
Card reader | SYSSQ 
Magnetic tape | SYSDA 
Direct access) 


T 

|Yes 


| SYSIN 


Input data to the 
load module 


Card reader | SYSSQ 
Magnetic tape j SYSDA 
Direct access | 


|No 


|FT06F001 


Printed output data 


Printer | A 


|Yes 


|FT07F001 


Punched output data 


Card punch | B 


|Yes 


| FTnnFnnn* 


User-defined sequential 
data set 


Unit- record | SYSSQ A,B 
Magnetic tape | 
Direct access | 


|No 


j FTnnFnnn* 


User-defined 
partitioned data set 
containing sequential 
members 


Direct access | SYSSQ 


|No 


| FTnnFnnn* 


User-defined Direct- 
access data set 


direct access j SYSDA 


|No 



JL X J. J. 

*nn and nnn cannot be set to 0. 



Data Sets That Must Be Defined by the 
Programmer 



The SYSIN DD statement must be defined by 
the programmer to complete the description 
of the input data set begun by the DD 
statement FT05F001. (If no input data set 
is to be submitted, the SYSIN DD statement 
is omitted and the operating system ignores 
the FT05F001 DD statement. ) 



An EBCDIC data set may reside on unit 
record devices, magnetic tape volumes or 
direct access volumes. Data sets defined 
on a tape or direct access device may be 
retained for use in later jobs; unit record 
data sets are temporary and exist for the 
current job only (although data from these 
data sets may be transmitted to permanent 
volumes during job processing). FT05F001, 
FT06F001, FT07F001, and SYSIN DD * all 
define sequential data sets. 



The FORTRAN programmer may define other 
data sets for use in the load module 
execution step. There are three types of 
data sets: sequential, partitioned, and 
direct-access. 



Figure 1-13 illustrates DD statements to 
define unit record data sets. Figure 1-14 
illustrates DD statements to create tape 
and direct access data sets. Figure 1-15 
illustrates DD statements to retrieve data 
sets. 



Sequential Data Sets 



A sequential data set may be coded either 
in EBCDIC (Extended Binary-Coded-Decimal 
Interchange Code) or in ASCII (American 
National Standard Code for Information 
Interchange) . ASCII data sets may be 
processed by the IBM System/360 Operating 
System only if the option ASCII=INCRES or 
ASCII=INCTRAN has been specified at the 
time the operating system is generated. 



An ASCII data set may reside only on 
magnetic tape volumes. Essentially, a 
programmer uses the same DD statement 
parameters to define an ASCII tape as he 
would an EBCDIC tape. The differences are 
that an ASCII tape must be identified 
either through the LABEL parameter 
(LABEL=AL) or through the DCB subparameter 
OPTCD (OPTCD=Q) and may be defined only on 
9-track tape having a density of 800 bpi. 
Figure 1-16 illustrates the corresponding 
DD statement for the one shown in Figure 
LM2 if an ASCII data set was being defined. 



68 



r 

Example 1 ; Data set in the input stream: 

//SYSIN DD * 
Example 2 ; Data set on the printer: 

//SYSPRINT DD SYSOUT=A 
Example 3 : Data set on the card punch: 

//FT07F001 DD SYSOUT=B 
Figure 1-13. Defining Unit Record Data Sets 



r 

[ Example 1 : Temporary Data set: 

//FT14F001 DD DSNAME= 6TEMP, UNIT=SYSSQ, SPACE= (TRK, (50) ) 

Example 2 : Permanent data set on a tape volume: 

//FT36F001 DD DSNAME=ANY, VOLUME=SER=7342, UNIT=2400, 

// DISP= (NEW, KEEP, DELETE) , LABEL=( , SL, EXPDT=69365) 

Example 3 : Permanent data set on a direct access volume: 

//FT41F001 DD DSNAME=SOME, DISP= (NEW, CATLG, DELETE) , UNIT=2 311, 
// VOLUME=SER=AA69,SPACE=(300, (100,100)), 

// DCB=(RECFM=VB,LRECL=304,BLKSIZE=612) 

L J 

Figure 1-14. Creating EBCDIC Sequential Data Sets on Tape or Direct Access Volumes 



r 1 

I Example 1 : Retrieving an uncataloged data set (to be kept at the end of the job) : | 

I I 

| //FT36F001 DD DSNAME=ANY, VOLUME=SER=7342, UNIT=2400, DISP=OLD | 

1 ! 

1 Example 2 : Retrieving a cataloged data set (to be deleted at the end of the job) : j 

I I 

j //FT41F001 DD DSNAME=SOME, DISP= (OLD, DELETE) | 

L J 

Figure 1-15. Retrieving Sequential Data Sets 



r 1 

Example 1 : Using the LABEL parameter: 

//FT36F001 DD DSNAME=ANY, VOLUME=SER=7342, UNIT=2400, 

// DISP= (NEW, KEEP, DELETE) , LABEL= ( AL, EXPDT=69365) 

Example 2 : Using the DCB parameter OPTCD subparameter : 

//FT36F001 DD DSNAME=ANY, VOLUME=SER=7342, UNIT=2400, 
// DISP=(NEW, KEEP, DELETE) ,DCB= (OPTCD=Q) 
L J 

Figure 1-16. Creating an ASCII Tape Data Set 



Load Module Execution 69 



Partitioned Data Sets 



Retriev i ng More Than One Member 



A partitioned data set (PDS) may reside 
only on a direct access device; hence, any 
DD statement parameters defining unit 
record or magnetic tape data sets are not 
applicable. 



A PDS consists of groups of sequential 
data which are called members of the data 
set. Partitioned data sets are used to 
contain libraries. 

Figure 1-17 illustrates DD statements to 
define partitioned data sets. 

Figure 1-18 illustrates DD statements to 
retrieve a member from a partitioned data 
set. The first example indicates that the 
member CASE2 is to be retrieved from the 
data set USERLIB, that the member is to be 
used for input operations (LABEL=(, , , IN) ) , 
and that the data set is to be retained at 
the end of the job (the absence of the 
second subparameter in DISP causes old data 
sets to be kept) . 

Like the first example, the second 
example retrieves a member for input 
operations, but the DELETE specification in 
the DISP parameter deletes the entire data 
set, including all members. 

The following discussion describes how 
more than one member may be processed in 
the same job and how a single member may be 
deleted from a partitioned data set. 



Two or more members of the same partitioned 
data set may be processed in one job in a 
sequential manner, i.e., the PDS must be 
closed for one member before attempting to 
read or write another member. Two or more 
members may be retrieved using either the 
READ statement END= option or the REWIND 
statement. 

P DS P rocessing U sing END=n Option ; When 
the END=n option is executed and a 
subsequent READ or WRITE statement is 
issued with the same data set reference 
number, the FORTRAN sequence number is 
incremented by one. This allows another 
member of the PDS referenced by the same 
data set reference number to be processed. 

The following FORTRAN program 
illustrates this method: 





INTEGER+4 X(20),Y(20> 


10 


READ (2,1,END=98) X 


1 


FORMAT (20A4) 




GO TO 10 


98 


READ (2,1,END=99) Y 




GO TO 98 


99 


WRITE (6,2) X, Y 




STOP 




END 



Execution of statement 10 results in 
processing the first PDS member which is 
referenced by the FORTRAN sequence number 
001. Assume that this member has the name 



Example 1 ; New Partitioned data set with its first member: 

//FT20F001 DD DSNAME=USERLIB (CASED , DISP= (NEW, CATLG) , UNIT=2311, 
// SPACE=(TRK, (50,20,5)) ,VOLUME=SER=DA31 

1 Example 2 : Adding a member to an existing data set: 

//FT20F002 DD DSNAME=USERLIB(CASE2) , DISP=OLD 

Example 3 : Temporary data set (created and deleted in the same job) : 

//FT21F001 DD DSNAME=&TEMPLIB(MY) , DISP= (NEW, PASS) , UNIT=SYSDA, 
// SPACE=(TRK, (20, 5,1)) 
L J 

Figure 1-17. Creating Partitioned Data Sets 



Example 1 : Retrieving a member of a data set: 

//FT25F001 DD DSNAME=USERLIB(CASE2) , DISP=OLD, LABEL= ( , , , IN) 
Example 2: Retrieving a member and deleting the data set at the end of the job: 

//FT26F001 DD DSNAME=USERLIB( CASED , DISP=( OLD, DELETE, KEEP) , LABEL=( , , , IN) 
Figure 1-18. Retrieving Partitioned Data Sets 



L J 



70 



CASE1 and resides in the cataloged 
partitioned data set named USERLIB; the DD 
statement that must be supplied is: 

//FT02F001 DD DSN=USERLIB( CASED , 

// LABEL= ( , , , IN) , DISP=OLD 

When the END=n option is executed in 
statement 10 and the next READ statement, 
statement 98, is encountered, the FORTRAN 
sequence number becomes 002. This closes 
the PDS for the first member. Another 
member may then be processed. If its name 
is CASE2, the DD statement that must be 
supplied is: 

//FT02F002 DD DSN=USERLIB(CASE2) , 

// LABEL= ( , , , IN) , DISP-GLD 



PDS i P rocessing Using REWIN D: Execution of 
the REWIND statement closes a data set. 
Any subsequent READ or WRITE statement 
opens the data set again. 

The following example illustrates the 
use of the REWIND statement in reading two 
members of the same PDS: 

INTEGER+4 X(20),Y<20) 
READ (2,1) X 
REWIND 2 
READ (3,1) Y 
WRITE (6, 2) X, Y 

1 FORMAT (20A4) 

2 FORMAT (' ' ,20A4) 
STOP 

END 

Execution of the first READ statement 
results in the processing of the first PDS 
member which is referenced by the FORTRAN 
sequence number 001. If the member has the 
name CASE1 and resides in the cataloged 
partitioned data set named USERLIB, the DD 
statement that must be supplied is: 

//FT02F001 DD DSN=USERLIB( CASED , 

// LABEL= ( , , , IN) , DISP=OLD 

When the REWIND statement is executed, the 
PDS is closed for MEMBER1. The next READ 
statement reopens the data set for another 
PDS member. If the next member name is 
CASE4, the DD statement that must be 
supplied is: 

//FT03F001 DD DSN=USERLIB(CASEU) , 

// LABEL= ( , , , IN) , DISP=OLD 



operating system utility program IEHPROGM. 
(IEHPROGM is described in the appropriate 
utilities publication, as listed in the 
Preface. ) Figure 1-19 illustrates how a 
job may be submitted to delete a member 
only. The DD statement named DD2 defines 
the data set. The utility program 
statement SCRATCH releases the member named 
CASE1 from the partitioned data set named 
USERLIB. 

The SCRATCH statement deletes only the 
directory entry that refers to the member; 
the space occupied by the member is 
released only if the entire data set is 
reorganized. To reorganize a partitioned 
data set, the programmer copies the members 
into a temporary data set, deletes and 
recreates the original data set, and copies 
the members back into it. The operating 
system utility programs contain facilities 
for copying members of partitioned data 
sets. 



Direct-Access Data Sets 



A direct-access data set may reside only on 
a direct access device; hence, any DD 
statement parameters defining unit record 
or magnetic tape data sets are not 
applicable. 

A direct-access data set consists of a 
number of records that may be accessed 
individually; i.e., only the record that is 
needed is accessed regardless of its 
physical position within the data set. A 
direct-access data set requires a 
corresponding DEFINE FILE statement in the 
FORTRAN program. Figure 1-20 illustrates a 
DD statement and the corresponding DEFINE 
FILE statement to create a direct-access 
data set. Note that the record 
characteristics described in the DEFINE 
FILE statement must agree with the space 
allocation requested in the DD statement 
(for example, in the example, both 
statements specify records, whose average 
length is 100 bytes, allocated in blocks of 
50 records). Figure 1-21 illustrates the 
statements to retrieve the direct-access 
data set. 

Note that the data set created in Figure 
1-20 was to be cataloged; therefore, to 
retrieve it, only the DSNAME and DISP 
parameters are required. 



Deleting One Member 



DCB PARAMETER CONSIDERATIONS 



To delete a member while retaining the 
remainder of the data set, the programmer 
submits a separate job executing the 



The following DCB subparameters define 
record characteristics of a data set: 



Load Module Execution 71 



RECFM, to specify the format of a 
record, for example, whether 
fixed-length, variable-length, or 
undefined-length, and whether records 
are blocked 

LRECL, to specify the size of a record 
or the maximum size of a 
variable-length record 



• BLKSIZE, to specify the size of a 
record or a block of records and the 
length of the buffers required to 
transmit data between main storage and 
input/output devices 

Table 1-12 lists the DCB default values 
for load module data sets. Table 1-13 
summarizes the maximum allowable values for 
the BLKSIZE subparameter. 



— i 



//SCRTCH JOB 

// EXEC 

//SYSPRINT DD 

//DD2 DD 

//SYSIN DD 



PGM=IEHPROGM 

SYSOUT=A 

UNIT=2311,VOLUME=SER=DA31,DISP=OLD 

* 



SCRATCH DSNAME=USERLIB, VOL=2311=DA31 , MEMBER=CASE1 



/* 



L J 



Figure 1-19. Deleting a Member of a Partitioned Data Set 



j DEFINE FILE 8 (50, 100, L, 12) 

I 

| //FT08F001 DD DSNAME=DADS, UNIT=SYSDA, VOLUME=SER=123478, 
j// DISP= (NEW, CATLG, DELETE) , SPACE=(100, (50,50) ) , 

j// DCB=(RECFM=F,BLKSIZE=100) 

L 



Figure 1-20. Creating a Direct-Access Data Set 



| DEFINE FILE 8 (50, 100, L, 12) 

I 

|//FT08F001 DD DSNAME=DADS, DISP=OLD 

L 

Figure 1-21. Retreiving a Direct- Access Data Set 



Table 1-12. DCB Default Values for Load Module Data Sets 
r t t— 






Sequential Data Sets 



ddname 



FT03Fyyy 
FT05Fyyy 
FT06Fyyy 
FT07Fyyy 
all others 



RECFM* 



U 

F 

UA 

F 

U 



LRECL 2 



80 

132 

80 



-T- 

I 

BLKSIZE | DEN 



Direct-Access Data Sets 

T T 



800 
80 

133 
80 

800 



BUFNO 



RECFM 



FA 

F 

F 

F 

F 



LRECL or 
BLKSIZE 



The value 
specified as the 
maximum size of 
a record in the 
DEFINE FILE 
statement. 



BUFNO 



x For records not under FORMAT control, the default is VS. 

2 For records not under FORMAT control, the default is 4 less than shown. 



72 



Table 1-13. Maximum BLKSIZE 


Values 


















1 1 

| L 








BLKSIZE 


Value 








1 r 

| Device Type j 

I- 4- 


Fixed- Length and Undef. 
Records (minimum value 


Lne< 
is 


a-L 

1) 


ength 


! 

i 


Varishl P— T»enrftll TiP*f~T>t-ric; 

(minimum value is 9) 


| Card Reader | 






80 














80 


| Card Punch j 






81 














89 


! Printer \ 
j 120 characters | 
| 132 characters | 
j 144 characters | 
| 150 characters | 






121 
133 
145 
151 














129 
141 
153 
159 


( Direct Access* - ' 
j 2301 ( 
| 2302 | 
j 2303 j 
| 2305 | 
j Mod I j 
| Mod II j 
| 2311 | 
| 2314 | 
| 3330 | 






20483 
4984 
4892 

14136 

14660 

3625 

7294 

13030 














20483 
4984 
4892 

14136 

14660 

3625 

7294 

13030 


| Magnetic Tape 2 | 

L _ -L_. 






32760 










_x 




32760 


r 

| iWith track overflow, 
j 2 The minimum value is 


the maximum BLKSIZE 
18. 


value 


is 


32760 


for 


each 


device. 



L J 



DCB Considerations for Sequential EBCDIC 
Data Sets 



buffer length is the same as the block 
length. 



FORTRAN records in an EBCDIC data set may 
be formatted or unformatted, i.e., they may 
or may not be defined in a FORMAT 
statement. List-directed I/O statements 
are considered formatted. Formatted 
records may be specified as fixed length, 
variable length, or of undefined length. 
Unformatted records may be specified only 
as variable length. If records are to be 
processed using asynchronous input/output, 
they may not be blocked. 



FORMATTED RECORDS : Formatted records are 
specified as follows: 

Fixed-Length Records : Unblocked 
fixed-length records are specified as 
RECFM=F; blocked records as RECFM=FB. For 
unblocked records, BLKSIZE specifies the 
record length, (e.g., BLKSIZE=80); the 
buffer length is the same as the record 
length. For blocked records, LRECL 
specifies the record length and BLKSIZE the 
block length, which must be a multiple of 
LRECL, (e.g., LRECL=80, BLKSIZE=400) ; the 



V ariable- Length Records : Unbl ocked 
variable-length records are specified as 
RECFM=V; blocked records as RECFM=VB. 

For unblocked records, LRECL specifies 
the maximum length of any record in the 
data set, plus four additional bytes for 
the segment control word that precedes each 
record, and BLKSIZE specifies the buffer 
length, which is LRECL plus four bytes for 
the block control word that precedes each 
block, (e.g., LRECL=84,BLKSIZE=88) ; the 
block control word is required even though 
the record is unblocked. If the record is 
smaller than the size specified in LRECL, 
unused space is not written. 

For blocked records, LRECL specifies the 
maximum record length plus four bytes for 
the segment control word, and BLKSIZE 
specifies the block length, a number equal 
to or larger than that specified in LRECL 
plus four bytes for the block control word, 
(e.g., LRECL=84,BLKSIZE=350). The block 
accommodates as many records as possible 
without exceeding the limit specified in 



Load Module Execution 73 



BLKSIZE. Unused space at the end of the 
block is not written. 

If LRECL is omitted, its default value is 
set to BLKSIZE-4, resulting in having only 
one record written in any block. 

Undefined-Length Records : Undefined- length 
records may be specified only as unblocked 
records, i.e., RECFM=U. BLKSIZE specifies 
the length of the buffer; this number must 
take into account the largest possible size 
record which may be encountered in the 
FORMAT statement; e.g., BLKSIZE=80 
indicates that no record larger than 80 
bytes will be encountered. Unused space is 
not written. 

Figure 1-22 illustrates the structure of 
formatted records in sequential data sets, 
using a FORTRAN record size of 80 
characters. An example of a DCB parameter 
describing a block of ten variable-length 
records whose maximum size is 121 is: 

DCB= (RECFM=VB, LRECL=125, BLKSIZE=1254) 



UNFORMATTED RECORDS ; Unformatted records 
are those not described by a FORMAT 
statement. The size of each record is 
determined by the input/output list of READ 
and WRITE statements. Unformatted records 
are always specified as variable and 
spanned. In addition, they may be blocked 
or unblocked. Unblocked records are 
specified as RECFM=VS f blocked records as 
RECFM=VBS. Blocked records reduce 



processing time substantially and are 
recommended whenever possible. 

For unblocked records, BLKSIZE specifies 
the length of the buffer and is immaterial 
to the size of the logical record, i.e., it 
may be larger than, equal to, or smaller 
than the logical record. The first eight 
bytes of the block are reserved for the 
block and segment control words. For a 
record smaller than or equal to 
BLKSIZE (-8), one record per block is 
transmitted; unused space is not written. 
For a record larger than BLKSIZE- 8, the 
record is transmitted over as many blocks 
as necessary to accommodate it; such a 
record is called a s p an ned record , since it 
spans more than one block. 

For blocked records, LRECL specifies the 
maximum record length, and BLKSIZE 
specifies a block length not necessarily a 
multiple of LRECL. The block accommodates 
as many records as possible. If necessary, 
the last record of a block may span to the 
next block. 

Figure 1-23 illustrates the structure of 
unformatted records in storage. 

Note : The track overflow feature may be 
specified with any of the record formats. 
This feature permits more efficient 
utilization of track capacity by allowing 
records to be written when a block size 
exceeds a track size. The feature is 
requested by the letter T in the RECFM 
subparameter, e.g., RECFM=VBT. 



74 



r 

FIXED- LENGTH RECORDS 

1. Unblocked, e.g., DCB=(RECFM=F,BLKSIZE=80) 

r 1 

I I 

| FORTRAN Record 1 | 

I I 

L J 

80 

2. Blocked, e.g., DCB=(RECFM=FB, LRECL=80,BLKSIZE=400) 

1 I I f / I ! 
j FORTRAN Record 1 | FORTRAN Record 2 | ( > | FORTRAN Record 5 J 

I ! ! i ( ! i 

L X X i ^, J. J 

80 160 320 400 



VARIABLE- LENGTH RECORDS 

1. Unblocked, e.g., DCB=(RECFM=V, LRECL=84,BLKSIZE=88) ; record may be any size up to 80 
bytes. 



r t t 1 

I B | S | | 

| C | C | FORTRAN Record 1 | 
I W | W | | 

L X J. J 

4 8 88 

2. Blocked, e.g., DCB=(RECFM=VB,LRECL=84, BLKSIZE=424) ; a record may be any size up to 
80 bytes, and the block will contain as many records as may be accommodated in 424 
bytes. 



I B | S | | S | | S | I S | / / | S | | 

| C | C | FORTRAN | C | FORTRAN | C | FORTRAN | C | f S | C | FORTRAN | 

| W | W | Record 1 | W j Record 2 | W j Record 3| W | \ 1 j W j Record n | 

L -L X -L X X X X X~?L S X X J 

4 8 424 



UNDEFINED-LENGTH RECORDS 

Unblocked only, e.g., DCB=(RECFM=U, BLKSIZE=80) ; a record may be any size up to 80 
bytes. 

r 1 

I I 

| FORTRAN Record 1 j 

I I 

L J 

80 



Legend : 



BCW=Block Control Word 
SCW=Segment Control Word 



Figure 1-22. EBCDIC Sequential Data Sets — Structure of Formatted Records 



Load Module Execution 75 



Unblocked Records, e.g., DCB=(RECFM=VS, BLKSIZE=68) ; assume two FORTRAN records, one 
50 characters in length, the other 130 characters 



r _ T _ T T ., r - T - T t r - T _ T 1 r - T - T T 1 

I B I S I I I I B|S| FORTRAN | | B | S | FORTRAN | | B | S | FORTRAN | | 

|C|C| FORTRAN | | |C|C| Record 2 | |C|C| Record 2 | |C|C| Record 2 | | 

|W|W|Record l|Unused| |W|W| Segment 1 j |W|W|Segment 2 j |W|W|Segment 3 |Unused| 

Ml | | | | | (60 chars) | | | |(60 chars) | | | | (10 chars) | | 

L_X_X X J L_X_X J l_X_X J L_X_X X J 

4 8 58 68 U 68 4 8 68 4 8 18 68 

Blocked Records, e.g., DCB=(RECFM=VBS, LRECL=130, BLKSIZE=200) ; assume three FORTRAN 
records, the first 130 characters in length, the second and third 100 characters in 
length 



l—T-T T~T 1 r - T _ T 1 -- T T 1 

|B|S| |S|FORTRAN | |B|S|FORTRAN |S| | | 

| C|C j FORTRAN Record 1 | C | Record 2 | |C|C (Record 2 |C|FORTRAN Record 3| | 

|W|W|(130 characters) |W| Segment 1 | |W|W|Segment 2 |W| (100 characters) | Unused | 

Ml I I (58 chars) | | | |(42 chars) | | | | 

L L_X X_X J L_X_X X_X X J 

4 8 138 142 200 4 8 50 54 154 200 



Legend ; 

BCW=Block Control Word 
SCW=Segment Control Word 



Figure 1-23. EBCDIC Sequential Data Sets — Structure of Unformatted Records 



DCB Considerations for ASCII Data Sets 



ASCII data sets may have sequential 
organization only and may reside only on 
9-track tape having a density of 800 bpi 
(the DCB subparameter DEN=2 must be implied 
or explicitly specified) . If an ASCII data 
set has not been identified by means of the 
LABEL parameter (LABEL=AL) , the programmer 
indicates the presence of an ASCII data set 
by specifying the DCB subparameter OPTCD=Q. 

FORTRAN records in an ASCII data set 
must be formatted and unspanned and may be 
fixed-length, undefined-length, or 
variable-length specified as follows: 



Fixed- Length Records : Like EBCDIC records, 
ASCII records may be blocked or unblocked. 
Unblocked records are defined as RECFM=F; 
blocked records as RECFM=FB. 

For unblocked records, BLKSIZE specifies 
the buffer length, which is the record 
length plus the length of an optional block 
prefix. The block prefix is a field that, 
if present, precedes each unblocked record 
or the first record in a block. BUFOFF 
specifies the size of the block prefix. 

For blocked records, LRECL specifies the 
record length and BLKSIZE the buffer 



length, which is the data length (a 
multiple of LRECL) plus the length of the 
block prefix if present. BUFOFF specifies 
the size of the block prefix. 

BUFOFF may be specified for input data 
sets only; the operating system does not 
use the information contained in the block 
prefix but skips the number of bytes 
specified before beginning record 
processing. If BUFOFF is specified for 
output data sets, abnormal termination may 
result. 

The following example defines a block of 
five records, each 80 bytes long, with a 
block prefix of 20 bytes: 

DCB=(RECFM=FB,LRECL=80,BLKSIZE=420, 
BUFOFF=20) 



Undefined-Length Records : Records may be 
unblocked only, defined as RECFM=U. 
BLKSIZE specifies the buffer length, which 
is the size of the largest record that may 
be encountered in the FORMAT statement plus 
the size of the block prefix if present. 
BUFOFF specifies the size of the block 
prefix. It may be coded for input data 
sets only. The operating system skips the 
number of bytes specified before beginning 
record processing. BUFOFF specified for 



76 



output data sets may result in abnormal 
termination. 

The following example specifies a buffer 
length of 200 bvtes with no block orefix: 



record processing. (Note that BUFOFF=4 is 
not equivalent to BUFOFF=L. ) BUFOFF=L may 
be specified for both input and output data 
sets. BUFOFF=n may be specified for input 



5-i-a ca*-c c-nV 



DCB=(RECFM=U,BLKSIZE=2 00) 



Variable-Length Records ; Records may be 
blocked or unblocked. Unblocked records 
a^e s r> e r, if ied 
as RECFM=DB. 



-ivcu jLC^vjiVjo 



For unblocked records, LRECL specifies 
the maximum length of any record in the 
data set plus four bytes for the segment 



- T- ~ 4- — . - e - ~ — , ~ 



control wuru uiat picueues ecicri recora. 
BLKSIZE specifies the buffer length, which 
is the same size as specified in LRECL plus 
the size of the block prefix if present. 
BUFOFF specifies the size of the block 
prefix. 

For blocked records, LRECL specifies the 
maximum record length plus four bytes for 
the segment control word. BLKSIZE 
specifies the buffer length, which is the 
block length plus the size of the block 
prefix if present. BUFOFF specifies the 
size of the block prefix. 

BUFOFF may be coded as BUFOFF=L or 
BUFOFF=n. BUFOFF=L indicates that the 
block prefix is four bytes long and is to 
be used in calculating the length of the 
block. BUFOFF=n indicates the size of the 
block prefix (where n is a number between 1 
and 99); the operating system skips the 
number of bytes specified before beginning 



The following example defines a block of 
up to 10 maximum length records (defined as 
100 bytes) with the block prefix to be used 
to calculate the block length: 

DCB=(RECFM=DB, LRECL=104, BLKSIZE=1044 , 
BUFOFF=L) 

Notes : 

1. ASCII data sets may specify only ASA 
carriage control characters in the 
RECFM subparameter (for example, 
RECFM=FBA) ; machine control characters 
(coded M in the RECFM subparameter) 
are not available for ASCII data sets. 

2. For efficient use of storage when 
writing blocked records, the 
programmer should always specify 
LRECL. If LRECL is omitted, its 
default value is set equal to the 
value of BLKSIZE less eight bytes. In 
output operations, the operating 
system checks to see if there is room 
in a block for a record of length 
LRECL; if there is not, the current 
block is written and a new one is 
started. The default convention thus 
results in having only one record 
written in any block. 

Figure 1-24 illlustrates the structure 
of records in ASCII data sets. 



Load Module Execution 77 



r 

FIXED-LENGTH RECORDS 



1. Unblocked, with no block prefix, e.g., DCB=(RECFM=F, BLKSIZE=80) . 



r t 

I I 

| FORTRAN Record | 

I I 

i j 

80 

2. Unblocked, with block prefix (input data sets only), e.g., 
DCB= ( RECFM=F, BLKSI ZE=9 , BUFOFF=l ) . 



r t 1 

| Block | j 

I j FORTRAN Record | 
| Prefix | | 

L JL J 

10 90 

3. Blocked, with no prefix, e.g., DCB=(RECFM=F,LRECL=80, BLKSIZE=4 00) . 



I I I / / I I 

| FORTRAN Record 1 | FORTRAN Record 2 | 5 < | FORTRAN Record 5 | 
I I I I \ I I 

L X X S> ^- X J 

80 160 320 400 

Blocked, with block prefix (input data sets only), e.g., 
DCB=(RECFM=FB,LRECL=80,BLKSIZE=420,BUFOFF=20). 

iBlOCk | | I / / I I 

| | FORTRAN Record 1 | FORTRAN Record 2 | f 5 | FORTRAN Record 5 | 
| Prefix | | | \ \ | | 

L X X X £ S X J 

20 100 180 340 420 



UNDEFINED- LENGTH RECORDS (Unblocked only) 

1. With no block prefix, e.g., DCB=(RECFM=U,BLKSIZE=80) ; a record may be any size up 
to 80 bytes. 



| FORTRAN Record | 
I I 

L J 

80 



2. With block prefix (input data sets only), e.g., 
DCB(RECFM=U,BLKSIZE=100,BUFOFF=20). 

r t n 

| Block | | 

j | FORTRAN Record j 
| Prefix | I 

l x j 

20 100 



Figure 1-24. ASCII Data Sets — Structure of Records 
(Part 1 of 2) 



78 



r 

VARIABLE- LENGTH RECORDS 

1. Unblocked, no block prefix, e.g., DCB=(RECFM=D, LRECL=84, BLKSIZE=84) ; a record 
may be any size up to 80 ijyfces. 



r t T 

! s | ! 

I C I FORTRAN Record | 
I W | | 

L X J 

4 84 

2. Unblocked, with block prefix, e.g., DCB= (RECFM=D,LRECL=84, BLKSIZE=94, BUFOFF=10> ; a 
record may be any size up to 80 bytes; a block prefix is not used to determine 
block length and may be specified only for an input data set. 



r t t 1 

| Block | S J | 

| | C | FORTRAN Record | 
| Prefix | W | I 

l x J. J 

10 14 94 

3. Blocked, no block prefix, e.g., DCB=(RECFM=DB,LRECL=84,BLKSIZE=420) ; a record may 
be any size up to 80 bytes, and the block will contain as many records as may be 
accommodated in 420 bytes. 



r T T T 7 S T T 1 

|S| |s| i/l s l I 

I C J FORTRAN Record 1 | C | FORTRAN Record 2s e | C | FORTRAN Record n | 

|W| |W| \\l w l I 

l x x x i > x x J 

4 420 

4. Blocked, with block prefix, e.g., DCB=(RECFM=DB, LRECL=84, BLKSIZE=424, BUFOFF=L) ; 
block prefix is used to determine block length. 



iBlock |S| |S| / / | S | | 

| | C I FORTRAN Record 1 | C | FORTRAN Record 2< \ | C | FORTRAN Record n| 

| Prefix | W | | W | \ \ | W | | 

L _ == X___X X X X X X L J 

4 8 424 



Leg end : 

SCW=Segment Control Word 



Figure 1-24. ASCII Data Sets — Structure of Records (Part 2 of 2) 



Load module Execution 79 



DCB Considerations for Direct-access Data 
Sets 



than BLKSIZE, the record is transmitted 
over as many blocks as are required to 
accommodate it. 



FORTRAN records may be formatted or 
unformatted, out must be fixed and 
unblocked only. The DEFINE FILE statement 
specifies the record length and buffer 
lenqth for a direct-access data set. This 
provides the default value for BLKSIZE. 

FOR MATTED RECORDS ; Record format is 
specified as RECFM=F (fixed). Record 
lenqth is specified by BLKSIZE, e.g., 
BLKSIZE=80. 

UNFORMAT TED RE CORDS: Record format is 
specified as RECFM=F, BLKSIZE specifies a 
pseudo block size, which, as for sequential 
data sets, may specify a length different 
from the record length. Unlike sequential 
data sets, no bytes are reserved for block 
or seqment control words. For a record 
smaller than or equal to BLKSIZE, one 
record per block is transmitted; unused 
space is left blank. For a record larger 



Figure 1-25 illustrates the structure of 
records in a direct-access data set. 

Notes ; 

1. Track-overflow, denoted by the letter 
T in the RECFM subparameter, may be 
specified to permit more efficient use 
of track capacity. 

2. If a direct-access data set is to be 
processed by non-FORTRAN programs, 
DSORG=DA must be specified, i.e., 

DCB=(RECFM=F, BLKSIZE=80, DSORG=DA) 

This specification causes the creation 
of a label indicating a direct-access 
data set. (If the data set is to be 
processed only by FORTRAN programs, 
the default specification, DSORG=PS, 
may be used. ) 



FORMATTED RECORDS 

May be fixed, unblocked only e.g., DCB=(RECFM=F, BLKSIZE=80) 



r 1 

I I 

| FORTRAN Record 1 | 



UNFORMATTED RECORDS 



.J 

80 



May be fixed, unblocked only 
Assume: A. DCB=(RECFM=F,BLKSIZE=80) 
B. Two Records 

Record 1 is 80 characters 
Record 2 is 100 characters 



r t 

| FORTRAN Record 2| 

| Segment 2 j Unused 



r 1 r 1 

| | | FORTRAN Record 2| 

I FORTRAN Record 1 | | Segment 1 | 

I | | (80 characters) | | (20 characters | 

l J L J l x. 

80 80 20 



80 



L J 



Figure 1-25. Direct-Access Data Sets — Structure of Records 



80 



IBM- SUPPLIED CATALOGED PROCEDURES 



Cataloged procedures provide pre-coded DD 
and EXEC statements for the most common 
functions, such as compile, or compile and 
execute. Cataloged procedures may be 
easily modified to accommodate special 



ai uua c_L<JUfc>. 



Cataloged procedures are sets of EXEC 
and DD statements that are placed in the 
procedure library, SYS1.PR0CLIB. Each 
procedure is retrieved by specifying its 
name in an EXEC statement; for example, to 
retrieve the procedure named FORTXC, the 
user submits the following EXEC statement: 

// EXEC FORTXC 

This statement retrieves the cataloged 
procedure named and places the statements 
from the procedure into the job stream. 



CATALOGED PROCEDURE RESTRICTIONS 



Cataloged procedures may consist only of 
EXEC statements, certain DD statements, 
and, optionally, PROC statements. PROC 
statements are used to assign default 
values to parameters. The PROC statement 
is discussed further in "Symbolic 
Parameters and the PROC Statement" later in 
this chapter. 

The following statements may not form 
part of a cataloged procedure: 

1. The JOB statement 

2. The JOBLIB DD statement 

3. A DD statement containing * or DATA in 
the operand field 

4. The delimiter statement 

5. The null statement 



6. An EXEC statement that calls another 
cataloged procedure; that is, only the 
form PGM=progname is valid 



FORTRAN PROCESSING CATALOGED PROCEDURES 



IBM supplies seven proceuurea ror use wxtn 
the FORTRAN IV (H Extended) Compiler. They 
are: 

1. FORTXC, to compile, illustrated in 
Figure 1-26. 

2. FORTXCL, to compile and link edit, 
illustrated in Figure 1-27. 

3. FORTXLG, to link edit and execute 
(load module execution), illustrated 
in Figure 1-28. 

4. FORTXCLG, to compile, link edit, and 
execute, illustrated in Figure 1-29. 

5. FORTXG, to execute, illustrated in 
Figure 1-30. 

6. FORTXCG, to compile and load, 
illustrated in Figure 1-31. 

7. FORTXL, to load, illustrated in Figure 
1-32. 

The first job control statement in each 
cataloged procedure is the PROC statement, 
which assigns default values to symbolic 
parameters. The statements identified by 
the characters //* following the PROC 
statement consist of comments only, giving 
more information about the symbolic 
parameters. A full discussion of the PROC 
statement and symbolic parameters may be 
found in the appropriate job control 
language reference publication, as listed 
in the Preface. The following discussion 
briefly describes their use in FORTRAN 
cataloged procedures. 



IBM-Supplied Cataloged Procedures 81 



MEMBER NAME FORTXC 








//FORTXC 


PROC 


FXPGM=IFEAAB, FXREGN=256K, 


FXPDECK=DECK, 


+39450000 


// 




FXPOLST=NOLIST,FXPOPT=0,FXLNSPC= , 32 00, (25,6)' 


39500000 


//* 










39550000 


//* 




PARAMETER 


DEFAULT-VALUE 


USAGE 


396C0000 


//* 










3965C000 


//* 




FXPGM 


IFEAAB 


COMPILER NAME 


39700C00 


//* 




FXREGN 


256K 


FORT-STEP REGION 


39750000 


//* 




FXPDECK 


DECK 


COMPILER DECK OPTION 


39800000 


//* 




FXPOLST 


NOLI ST 


COMPILER LIST OPTION 


3985C000 


//* 




FXPOPT 





COMPILER OPTIMIZATION 


399C0000 


//* 




FXLNSPC 


3200,(25,6) 


FORT. SYSLIN SPACE 


39950000 


//* 










40000000 


//FORT 


EXEC 


PGM=&FXPGN 


,REGION=£FXREGN 


,C0ND=(4,LT), 


+40050000 


// 




PA*M='£FXPDECK,&FXPOLST,OPT(£FXPOPT) ■ 


40100300 


//SY SPRINT 


DO SYSOUT= 


A,DCB=BLKSIZE=3429 


40150000 


//SYSUT1 




DD UNIT=SYSSQ,SPACE=(3465 


,(3,3) ),DCB=BLKSIZE=3465 


40200000 


//SYSUT2 




DD UNIT=SYSSQ,SPACE=(2048 


,( 10,10) ) 


4025C000 


//SYSPUNCH 


DO SYSOUT= 


B,DCB=BLKSIZE=3440 


403C0000 


//SYSLIN 




DD DSN=&£LOADSET,DISP=( MOD, PASS ) t UNI T=SYS SQ , 


+40350000 


// 




SPACE=UFXLNSPC) , DCB=BLKS IZ E=3200 


40400000 



Figure 1-26. Cataloged Procedure FORTXC 



82 



MEMBER NAM 
//FORTXCL 

n 

//* 
//* 
//* 
//* 
//* 
//* 
//* 
//* 
//* 
//* 
//* 

//FORT E 

If 

//SYSPRINT 

//SYSUT1 

//SY SUT2 

//SYSPUMCH 

//SYSLIN 

If 

//LKEO E 

II 

//SYSPRINT 

//SYSLIB 

//SYSUT1 

//SYSLMOD 

II 

//SYSLIN 

II 



E FORTXCL 

PROC FXPGM = IFEAAB, FXREGN=256K, FXPDECK=NODECK, F XPOL ST = NOL I ST, 
FXPNAME=MAIN,FXPOPT=0,PGMLB='£&GOSET' 



XEC 



XEC 



PARAMETER DEFAULT-VALUE 



FXPGM 

FXREGN 

FXPDECK 

F XPOL ST 

FXPNAME 

FXPOPT 

PGMLB 



IFEAAB 

256K 

NODECK 

NOLI ST 

MAIN 



&&GOSET 



USAGE 

COMPILER NAME 
FORT-STEP REGION 
COMPILER DECK OPTION 
COMPILER LIST OPTION 
COMPILER NAME OPTION 
COMPILER OPTIMIZATION 
LKED. SYSLMOD DSNAME 



PGM=SFXPGM,REGI0N=&FXREGN,C0ND=(4,LT) , 

p Ap,M = i &FXPDECK j & p XPOL ST t NAME { &FXPNAME ) , OPT{ &F XPOPT } ' 

DD SYS0UT=A,DCB=BLKSIZE=3429 

DD UNIT=SYSSQ,SPACE=(3465,(3,3) ) , DCB=BLKS IZE=3465 

DD UNIT=SYSSQ,SPACE=<2048,<10,10) ) 

DD SYS0UT=B,DCB=BLKSIZE=3440 

DD DS N=£S LOADS ET,DISP=( MOD, PASS), UN IT=SYSSQ, 

SPACE=( 32 00,(25,6) ) ,DCB=BLKS I ZE=3200 

PGM=IEWL,REGI0N=96K,C0ND=(4,LT) , 

PARM='LET,LIST,MAP,XREF« 

DD SYSOUT=A 

DD DSN=SYS1.F0RTLIB,DISP=SHR 

DD UNIT=SYSDA,SPACE=( 10 24, ( 200,20) ) 

DD DSN=£PGMLB.( &FXPNAME ) , UNIT=SYSDA, 

DISP=(NEW,PASS) ,SPACE=(TRK, ( 10, 10 , 1 ) , RLSE ) 

DD DSN=££LOADSET,DISP=( OLD, DELETE) 

DD DDNAME=SYSIN 



+41350000 
41400000 
41450000 
415000 00 
41550000 
41600000 
41650000 
41700000 
41750000 
418000 00 
41850000 
41900000 
41950000 

+42000000 

^TC \J -/ \J \J \J\J 

42100000 
4215000C 
42200000 
42250000 

+42300000 
42350000 

+42400000 
42450000 
42 50 00 00 
42 55 00 00 
42600000 

+42650000 
42700000 
42750000 
42800000 



Figure 1-27. Cataloged Procedure FORTXCL 



IBM- Supplied Cataloged Procedures 83 



MEMBER NAME FORTXLG 




//FORTXLG PROC 


LKLNDD= , DDNAME=SYSIN' , GOPGM=MA IN, GOREGN= 1COK, 


+44850C00 


// 


GOF5DD= , DDNAME=SYSIN' , GOF 600=' S YSOUT= A' , 


+44900C00 


// 


G0F7DD= , SYS0UT=B« 


44950000 


//* 




45000000 


//* 




45050000 


//* 


PARAMETER DEFAULT-VALUE USAGE 


45100000 


//* 


LKLNDD DDNAME=SYSIN LKEO. SYSLIN OPERAND 


45150CC0 


//* 


GOPGM MAIN OBJECT PROGRAM NAME 


45200000 


//* 


GOREGN 100K GO-STEP REGION 


45250000 


//* 


G0F5DD DDNAME=SYSIN G0.FT05F001 OPERAND 


45300000 


//* 


G0F6DD SYSOUT=A GO.FT06F001 OPERAND 


45350000 


//* 


G0F7DD SYSOUT=B G0.FT07F0C1 OPERAND 


45400000 


//* 




45450C00 


//LKEO EXEC 


PGM=IEWL,REGI0N=96K,C0ND=(4,LT) , 


+45500000 


// 


PARM=»LET,LIST,MAP,XREF' 


45550000 


//SYSPRINT 


DD SYSOUT=A 


45600000 


//SYSLIB 


DD DSN=SYS1.F0RTLIB,DISP=SHR 


45650000 


//SYSUT1 


DD UNIT=SYSDA,SPACE = ( 10 24, ( 200,20) 


45700000 


//SYSLMOD 


DD DSN=£&GOSETUGOPGM),DISP=( ,PASS) ,UNIT = SYSDA, 


+45750000 


// 


SPACE=(TRK,(10,10,1),RLSE) 


45800000 


//SYSLIN 


DD &LKLNDD 


45850000 


//GO EXEC 


PGM=*.LKED.SYSLM0D,REGI0N=&G0REGN,C0ND=(4,LT) 


45900000 


//FT05F0C1 


DD GG0F5DD 


45950000 


//FT06F001 


DD SG0F6DD 


4600000C 


//FT07F0C1 


DD SG0F7DD 


46050000 



Figure 1-28. Cataloged Procedure FORTXLG 



84 



NEMBER NAME F 


ORTXCLG 




//FORTXCLG PR3C FX PGM= I F EAAB , FXREGN=256K , FXPDECK=NODECK, 


+42900000 


// 


FXPOLST=NOLIST,FXPOPT=0,GOREGN=100K, 


+42950000 


// 


GOF500='DDNAME=SYSIN' , G0F6DD= • S YSOUT= A 1 , 


+430C0C0C 


// 


rnr"7r»r\- ■ CVCHIIT-D 9 

wui ' Lr u/ - ^j ■ vJ t_r v*/ I — U 


43050000 


//* 




4310C000 


//* 


PARAMETER DEFAULT-VALUE USAGE 


43150000 


//* 




43200000 


//* 


FXPGM IFEAAB COMPILER NAME 


43250000 


//* 


FXREGN 256K FORT-STEP REGION 


43300000 


//* 


FXPDECK NODECK COMPILER DECK OPTION 


43350000 


// * 


FXPOLST NuLIST COMPILER LIST OPTION 


4340CC00 


//* 


FXPOPT C COMPILER OPTIMIZATION 


4345000C 


//* 


GOREGN 100K GO-STEP REGION 


435C0000 


//* 


GOF5DD DDNAME=SYSIN GO.FT05FOO1 OPERAND 


43550000 


//* 


G0F6DD SYSOUT=A GO.FTCSFCC1 OPERAND 


43600000 


//* 


G0F7DD SYSOUT=B GO.FT07FC01 OPERAND 


43650000 


//* 




43700000 


//FORT EXEC 


PGM=£FXPGM,REGI0N=£FXREGN,C0ND=(4,LT) , 


+43750000 


// 


PA=*M='&FXPDECK,&FXPOLST,OPTUFXPOPT) • 


43800000 


//SY SPRINT 


DD SYS0UT=A,DCB=BLKSIZE=3429 


43850000 


//SYSUT1 


DD UNIT=SYSSQ,SPACE=(3465,(3,3) ) , DCB= BLKS IZE= 3465 


43900000 


//SYSUT2 


DD UNIT=SYSSQ,SPACE=<5048,( 10,10) ) 


43950000 


//SYSPUNCH 


DD SYS0UT=B,DCB=BLKSIZE=3440 


44000000 


//SYSLIN 


DD DSN=&£LOADSET,DISP=(MOD, PASS) ,UNIT=SYSSQ» 


+44050000 


// 


SPACE=(3200,(25,6) ) ,DCB=BLK SI ZE=3200 


44100C00 


//LKED EXEC 


PGM=IEWL,REGI0N=96K,C0ND=(4,LT) , 


+44150000 


// 


PARM='LET,LIST,MAP,XREF« 


44200000 


//SY SPRINT 


DD SYSOUT=A 


44250000 


//SYSLIB 


DD DSN=SYS1.F0RTLIB,DISP=SHR 


44300C0C 


//SYSUT1 


DD UNIT=SYSDA,SPACE=( 10 24,( 200,20)) 


44350000 


//SYSLMOD 


DO DSN=6£G0SET( MA IN ) , DIS P = ( , PASS) , UNI T= SYSD A, 


+44400000 


// 


SPACE=(TRK,(10,10,1 ),RLSE) 


44450000 


//SYSLIN 


DD DSN=SSLOADSET,DISP = { OLD, DELETE) 


44500000 


// 


DD DDNAME=SYSIN 


445500 00 


//GO EXEC 


PGM=*. L KE D.SYSL MOD, REGION=£ GOREGN, CON D=( 4, LT) 


44600000 


//FT05F001 


DD &G0F5DD 


44650000 


//FT06F001 


DD CG0F6DD 


44700000 


//FT07F001 


DD &G0F7DD 


44750000 



Figure 1-29. Cataloged Procedure FORTXCLG 



IBM-Supplied Cataloged Procedures 85 



VEMBER NAME f 


: ORTXG 






//FORTXG PROC 


GOPGM=MAIN,GOREGN=100K, 




+4050CC00 


// 


GOF5DD= , DDNAME=SYSIN' , G0F6DD= ' SYSOUT= A* , 




+40550000 


// 


GOF70D= , SYSOJT=B« 




40600000 


//* 






40650000 


//* 


PARAMETER DEFAULT-VALUE USAGE 




407C0C00 


//* 






40750000 


//* 


GOPGM MAIN PROGRAM NAME 




40800000 


//* 


GOREGN 100K GO-STEP REGION 




408500 00 


//* 


GOF5DD DDNAME=SYSIN GO.FT05F001 DO 


OPERAND 


40900000 


//* 


G0F6DD SYSOUT=A G0.FT06F0C1 DD 


OPERAND 


40950000 


//* 


G0F7DD SYSOUT=B GO.FT07F0C1 DD 


OPERAND 


41000000 


//* 






41050000 


//GO EXEC 


PGM=£G0PGM,REGI0N=&G0REGN,C0ND=(4,LT) 




41100000 


//FT05F001 


DD &GOF5DD 




41150000 


//FTC6F001 


DD &G0F6DD 




41200000 


//FT07FQ01 


DD &G0F7DD 




41250000 



Figure 1-30. Cataloged Procedure FORTXG 



86 



MEMBER NAME FORTXCG 








//FORTXCG PROC 


FXPGM=IFEAAB, FXREGN=2 56K, 


FXPDECK=NODECK, 


+46150000 


// 


FXPOLST=NOLIST,FXPOPT=0,GOF5DD= , DDNAME=SYSIN , , 


+46200000 


// 


Gur 6DD= ! SYSGUT=A i , GOF7DD= 


■SYSOUT=B* ,GOREGN=100K 


46250000 


//* 








46300000 


//* 


PARAMETER 


DEFAULT-VALUE 


USAGE 


46350000 


//* 








46400000 


//* 


GOREGN 


100K 


GO-STEP REGION 


4645 00 00 


//* 


FXPGM 


IFEAAB 


COMPILER NAME 


46500000 


//* 


FXREGN 


256K 


FORT-STEP REGION 


46550C00 


//* 


FXPDECK 


NODECK 


COMPILER DECK OPTION 


466000 00 


//* 


FXPOLST 


NOLI ST 


COMPILER LIST OPTION 


46650000 


//* 


FXPOPT 





COMPILER OPTIMIZATION 


46700000 


//* 


GOF5DD 


DDNAME=SYSIN 


GO.FT05F001 OPERAND 


46750000 




G0F6DD 


SYSOUT=A 


G0.FT06F001 OPERAND 


4680000C 


//* 


G0F7DD 


SYSOUT=B 


GO.FT07F001 OPERAND 


46850000 


//* 








46900000 


//FORT EXEC 


PGM=£FXPGM 


,REGI0N=£FXREGN 


,C0ND=(4,LT) , 


+46950000 


// 


P AR M=« £F X PDEC K, &FXPOL ST, OPTU FXPOPT)' 


47000000 


//SY SPRINT 


DD SYSOUT=/ 


\,DCB=BLKSIZE=3429 


47050C00 


//SYSUT1 


DO UNIT=SYSSQ,SPACE=(3465 


,(3,3) ),DCB=BLKSIZE=3465 


47100000 


//SYSUT2 


DD UNIT=SYSSQ,SPACE=(2048 


,( 10,10) ) 


47150000 


//SYSPUNCH 


DD SYSOUT= 


3,DCB=BLKSIZE=3440 


47200000 


//SYSLIN 


DD DSN=S&LOADSET,DISP=(MOD,PASS),UNIT=SYSSQ, 


+47250000 


// 


SPACE=( 32 00,(25,6)) ,DCB=BLKSI ZE=3200 


47300000 


//GO EXEC 


PGM=L0ADER 


,C0ND=(4,LT),REGI0N=£G0REGN, 


+47350000 


// 


PARM='LET, 


MORES, EP= MAIN' 




47400000 


//SYSLOUT 


DD SYSOUT= 


\ 




47450000 


//SYSLIB 


DD DSN=SYS1.F0RTLIB,DISP= 


SHR 


475000 00 


//SYSLIN 


DD DSN=££LOADSET,DISP=( OLD, DELETE) 


47550000 


//FT05F001 


DD SG0F5DD 






47600000 


//FT06F001 


DD SG0F6DD 






47650000 


//FT07F001 


DD &G0F7DD 






47700000 



Figure 1-31. Cataloged Procedure FORTXCG 



IBM-Supplied Cataloged Procedures 87 



MEMBER N 

//FORTXL 

// 

//* 

//* 

//* 

//* 

//* 

//* 

//* 

//* 

//GO 

// 

//SYSLGU 

//SYSLIB 

//FT05F0 

//FT06F0 

//FT07F0 



AME FORTXL 

PROC GOF5DD=«DDNAME=SYSIN« ,G0F6DD= • SYSOUT= A« 
G0P7DD='SYS0UT=B' ,GOREGN=100K 



EXEC 



OL 
01 
01 



PARAMETER DEFAULT-VALUE 

G0F50D DDNAME=SYSIN 

G0F6DD SYSOUT=A 

G0F7DD SYSOUT=B 

GOREGN 100K 



USAGE 

G0.FT05F001 OPERAND 
G0.FT06F001 OPERAND 
G0.FT07F001 OPERAND 
GO-STEP REGION 



PGM=L0ADER,C0N0=(4,LT),REGI0N=&G0REGN, 

PARM=»LET,NORES,EP=MAIN« 

DD SYSOUT=A 

DO DSN=SYS1.F0RTLIB,DISP=SHR 

DD &G0F5DD 

DD &G0F6DD 

DD &G0F7DD 



+47800C00 
47850C00 
47900C00 
47950000 
48000000 
48050C00 
48100000 
48150000 
48200000 
48250C00 

+48300000 
48350000 
48400000 
48450000 
48500000 
485500 00 
48600000 



Figure 1-32. Cataloged Procedure FORTXL 



S ymbolic Parameters and the PROC Statement 



A symbolic parameter is a name preceded by 
an ampersand (&). It appears in the 
operand field of a statement and stands as 
a symbol for a parameter, a subparameter, 
or a value. For example, in the cataloged 
procedure FORTXC, the EXEC statement named 
FORT contains a number of symbolic 
parameters, such as SFXPGM and SFXREGN in 
the expressions PGM=&FXPGM and 
REGION=&FXREGN. 

Symbolic parameters are used to make a 
cataloged procedure easily modified when it 
is called. The programmer may assign 
values to symbolic parameters when he calls 
a cataloged procedure, or he may permit the 
default value assigned by the PROC 
statement to be in effect. 

Figure 1-33 illustrates the format of 
the PROC statement. Since the statement 



deals only with the symbolic parameters, 
the identifying ampersand is unnecessary 
and is omitted. In the cataloged procedure 
FORTXC, the PROC statement assigns default 
values to &FXPGM and SFXREGN in the manner: 



//FORTXC PROC FXPGM=IFEAAB, FXREGN=228K, ... 



When the cataloged procedure is executed, 
these default values are assigned if the 
programmer does not override them. That 
is, the EXEC statement named FORT would 
appear as if it were coded: 

//FORT EXEC PGM=IFEAAB,REGION=228K, ... 

Figure 1-34 is another example 
illustrating how the PROC statement affects 
symbolic parameters of a cataloged 
procedure. For easier reference, the 
symbolic parameters in Figure I- 34 are 
shown underscored. 



r t t i 

| Name | Operation | Operand | 

,. + x ^ 

| //[name] | PROC | symbolic-parameter=value [, . . . ] | 

i x x J 

Figure 1-33. PROC Statement Format 



88 



PROC Statement in cataloged procedure FORTXCLG: 



/ / r UKIAL Lilo 

// 

// 

// 



rArbw-irtftHD, r akjajin — zzoj\, r ajtjj£.>-j\— ixuuriUJ\ t 
FXPOLST =NOLIST. FXPOPT=0 , GOREGN=100K, 
G0F5Dp=' DDNAME=SYSIN' , G0F6DD=' SYSOUT=A' , 
G0F7DD=» SYSOUT=B' 



Statements in FORTXCLG specifying symbolic parameters: 



//FORT 
// 



EXEC 



//GO EXEC 
//FT05F001 DD 
//FT06F001 DD 
//FT07F001 DD 



PGM= SFXPGM , REGION=SFXREGN, COND= ( 4, LT) , 
PARM= • SFXPDECK , SFXPOLST, OPTIMI ZE ( SFXPOPT) 



PGM=*. LKED. SYSLMOD, REGION=6GOREGN # COND= (4, LT) 

SGOF5DD 

SGOF6DD 

&GOF7DD 



Substitution of default values at execution time: 



//FORT 
// 



EXEC 



//GO EXEC 
//FT05F001 DD 
//FT06F001 DD 
//FT07F001 DD 



PGM=IFEAAB, REGION=228K, COND= ( 4 , LT) , 
PARM='NODECK,NOLIST, OPTIMI ZE(0) ■ 



PGM=*. LKED. SYSLMOD, REGION=100K, COND=( 4, LT) 

DDNAME=SYSIN 

SYSOUT=A 

SYSOUT=B 



Figure 1-34. Effect of PROC Statement in a Cataloged Procedure 



COMPILING 



LINK EDITING 



The EXEC statement for the compilation step 
is named FORT and, through the PGM 
parameter, specifies the compiler as the 
program to be executed (PGM=IFEAAB) . The 
DD statements describe data sets required 
by the compiler. SYSLIN describes the 
output of the compilation step, an object 
module stored as a temporary data set named 
SSLOADSET. (A double ampersand is assigned 
to avoid confusion with symbolic 
parameters, which are preceded by one 
ampersand. ) The DISP parameter is coded 
(MOD, PASS); MOD permits more than one 
object module to be stored (if many source 
modules are submitted for compilation), and 
PASS permits the data set to be used in 
later job steps. The programmer specifies 
the source module data set in a SYSIN DD 
statement coded as follows: 



//FORT. SYSIN DD 



* (or appropriate 

parameters to define 
the data set) 



The EXEC statement for the link edit step 
is named LKED and specifies the linkage 
editor as the program to be executed 
(PGM=IEWL). In FORTXCL and FORTXCLG, the 
EXEC statement COND parameter indicates 
that the program is to be executed only if 
the FORT step has returned a code less than 
or equal to 4. (Each job step issues a 
return code indicating the results of 
processing, e.g., for normal completion, 
4 for minor errors detected, 8 for serious 
errors. ) The DD statements describe 
required data sets. SYSLMOD describes the 
output of the link edit step, a load module 
named MAIN, which is stored as a member of 
a temporary library named 6&G0SET. SYSLIN 
describes the input to the linkage editor. 
When the linkage editor is to be the first 
step executed, as in FORTXLG, SYSLIN 
indicates the object module defined by a 
SYSIN DD statement which the programmer 
must supply, as follows: 

//LKED. SYSIN DD * (or appropriate 
parameters) 



IBM-Supplied Cataloged Procedures 89 



EXECUTING THE LOAD MODULE 



The EXEC statement for the go step is named 
GO, and specifies, as the program to be 
executed, the load module created in the 
link edit step (PGM=*.LKED. SYSLMOD) . The 
COND parameter indicates that the program 
is to be executed only if previous steps 
returned a code less than or equal to 4. 
The DD statements describe required data 
sets. DD statement FT05F001 indicates that 
the input data set is to be defined by a 
SYSIN DD statement which the programmer 
must supply. FT06F001 defines a printer 
data set; FT07F001 a card punch data set. 

The programmer specifies input to the 
load module by a SYSIN DD statement coded 
as follows: 



Figure 1-35 at the end of this chapter 
illustrates how a programmer may modify a 
cataloged procedure using some of the 
examples described below. 



MODIFYING PROC STATEMENTS 



The programmer modifies PROC statement 
parameters by specifying the changes in the 
EXEC statement that calls the procedure. 
When he changes a PROC statement parameter, 
the programmer is assigning a temporary 
value to a symbolic parameter, and this 
value is transferred to the appropriate 
parameter in the EXEC or DD statement in 
the cataloged procedure when it is 
executed. 



//GO. SYSIN DD * (or appropriate parameters) 



LOADING 



The EXEC statement for the loader step is 
named GO, and specifies the loader as the 
program to be executed ( PGM= LOADER) . The 
DD statements describe required data sets. 
SYSLOUT describes printed output, such as a 
module map. The other data sets are the 
same ones as used by the linkage editor and 
the load module. Note that a SYSLMOD DD 
statement is not specified; the loader 
places the load module directly into 
storage for execution. When the loader is 
to be the first step executed, as in 
FORTXL, the object module must be defined 
in a SYSLIN DD statement (not SYSIN), 
supplied by the programmer, as follows: 



//GO. SYSLIN DD 



(or appropriate 
parameters) 



Input to the load module is defined in a 
SYSIN DD statement, as follows: 



//GO. SYSIN DD 



(or appropriate 
parameters) 



For example, to change the region size 
of the compiler from 228K to 200K, and to 
change card punch output in the load module 
from output class B to output class C, the 
programmer may use the following statement 
(assume that changes are being made to 
FORTXCLG for this and for all examples in 
this chapter) : 

// EXEC FORTXCLG, FXREGN=200K, 
// G0F7DD= ' SYSOUT=C • 

Note that the ampersand preceding a 
symbolic parameter is not coded; note also 
that a value containing a special 
character, as in SYSOUT=C, is enclosed in 
apostrophes. 

Prior to being called, the appropriate 
statements in FORTXCLG appear as follows: 

//FORT EXEC PGM=&FXPGM, REGI0N=6FXREGN, ... 



//FT07F001 DD &G0F7DD 

When the cataloged procedure is called, the 
statements appear as though they were 
coded: 

//FORT EXEC PGM=IFEAAB, REGION=200K, ... 



MODIFYING CATALOGED PROCEDURES 



Except for the PGM parameter, any parameter 
in the PROC, EXEC, or DD statements may be 
modified. New parameters may be added; 
existing parameters may be overridden. 
Parameters not overridden continue to 
remain in effect. 

When a cataloged procedure is modified, 
the changes apply only for the duration of 
the job. 



//FT07F001 DD SYSOUT=C 

Note that a symbolic parameter not changed 
(PGM=5FXPGM) retains its default value. 

An alternative method to change a value 
is by assigning the new value directly to 
the parameter itself, not the symbolic 
parameter associated with it. For example, 
the region size may be changed by 
specifying REGION=200K in place of 
FXREGN=200K. (Actually, in this example, 



90 



the region size for all job steps would be 
changed; to change the region size only for 
the compile job step, the appropriate job 
step name. FORT, must also appear in the 
parameter, i.e., REGION. FORT=200K. ) 



3. Change mo re than one parameter: For 
example, to modify FORT by changing 
the region from 228K to 200K and the 
PARM option NOLIST to LIST S he may use 
the statement: 



MODIFYING EXEC STATEMENTS 



//SOME EXEC FORTXCLG, 

// REGION. FORT=20 OK, 

// PARM. FORT=LIST 



The programmer modifies EXEC statement 4. 
parameters by specifying the changes in the 
EXEC statement that calls the procedure. 

The following rules apply to EXEC 
statement mcuii ica Liens • 

• Parameters are overridden in their 
entirety. If the programmer wishes to 
retain some options while changing 
others, he must respecify the options 
he wishes kept. (However, default 
options remain in effect if not 
overridden. ) 5. 

• Parameters specified for individual job 
steps use the form: 

keyword. stepname=value 

where : 

keyword indicates the name of the 

parameter 
stepname indicates the name of the 

procedure, for example, 

REGION. FORT=value 



Change more than one ste p : For 
example, to modify FORT by specifying 
TIME and to modify LKED by raising the 
condition code from 4 to 8, he may use 
the statement : 

//ANY EXEC FORTXCLG, TIME. F0RT=5, 
// COND. LKED= ( 8 , LT ) 

Note that the user may add a parameter 
while revising an existing one. 



Combine change s to sy m bolic parameters 
a nd EXEC statement parameters : For 
example, to modify the symbolic 
parameter FXREGN, and to add the TIME 
parameter to the FORT EXEC statement, 
he may use the statement: 

//ANY EXEC FORTXCLG, FXREGN=200K, 
// TIME. F0RT=5 



Parameters not specifying stepname are 
assumed to apply to all steps in the 
procedure; for example, REGION=value 
applies to the entire cataloged procedure. 

• To make changes to more than one 
step, the programmer must specify all 
changes for an earlier step before 
those for later steps. 

• Changes to symbolic parameters and 
EXEC statement parameters may be 
combined on the same card. 

The programmer may make the following 
modifications : 



MODIFYING DD STATEMENTS 



The programmer modifies DD statements by 
submitting new DD statements after the EXEC 
statement that calls the procedure. As 
with modifications to EXEC statements, the 
user may override or add parameters to DD 
statements in one or many steps. In 
addition, he may add entirely new DD 
statements to any step (whenever he 
supplies a SYS IN DD statement, the 
programmer is adding a new DD statement). 

The following rules apply to DD 
statement modifications: 



1. Override existing parameters : For 
example, to modify the LKED step by 
raising the condition code from 4 to 
8, he may use the statement: 

//SOMENAME EXEC FORTXCLG, 

// C0ND.LKED=(8,LT) 

2. Add new parameters : For example, to 
modify FORT by specifying the TIME 
parameter, he may use the statement: 

//ANYNAME EXEC FORTXCLG, TIME. FORT= 5 



• Parameters are overriden in their 
entirety except for the DCB parameter 
where individual subparameters may be 
overridden 

• Parameters are nullified by specifying 
a comma after the equal sign in the 
parameter, e.g., UNIT=, 

• Parameters are overridden when mutually 
exclusive parameters are specified in 
their place, e.g., SPLIT overrides 
SPACE 



IBM-Supplied Cataloged Procedures 91 



• DD statements must indicate the related 
procedure step, using the form 
//stepname. ddname , e.g., //FORT. SYS IN 

• To make changes in more than one step, 
the user must specify all changes for 
an earlier step before those for later 
steps 

• To modify more than one DD statement in 
a job step, the programmer must specify 
the applicable DD statements in the 
same sequence as they appear in the 
cataloged procedure 

The programmer may make the following 
modifications : 



3. Add new DD statements . For example, 
to add new data sets having data set 
reference numbers 10 and 15 for 
processing in the go step, the user 
may submit the statements : 



//GO.FT10F001 DD 

// 

// 

// 

//GO.FT15F001 DD 

// 

// 

// 

// 



DSNAME=DSET1 , 
DISP= ( NEW, DELETE ) , 
V0LUME=SER=T1132 , 
UNIT=TAPE 
DSNAME=DSET2, 
DISP=(, DELETE), 
VOLUME= SER=D A 4 5 , 
UNIT=2311, 
SPACE=(TRK, (10, 10)) 



1. Override existing parameters . For 

example, to modify SYSLMOD so that the 
load module is stored in a private 
library rather than in the system 
library, the user may submit the 
statement: 

//LKED. SYSLMOD DD DSNAME=PRIV(PROG) , 
// DISP= (MOD, PASS) 

In this example the library PRIV is 
assumed to be an old library and is 
cataloged (that is, VOLUME and UNIT 
parameters need not be specified). 
Note that in subsequent uses of the 
library a JOBLIB DD statement, 
defining the private library, must 
also be submitted to make the library 
available to the system. 

2« Add new p a rameters . For example, to 
store the load module in a new, 
uncataloged library, the programmer 
must specify the VOLUME, UNIT, and 
SPACE parameters. He may submit the 
statement: 

//LKED. SYSLMOD DD DSNAME=MYLIB ( FIRST) , 

// DISP= ( NEW, PASS ) , 

// VOLUME=SER=11234, 

// UNIT=SYSDA, 

// SPACE=(TRK, (50,10,2)) 



Note that the user may explicitly 
define a data set as new (DISP 
parameter for FT10F001) or may permit 
the system to assume a new data set by 
default (DISP in FT15F001). 

Figure 1-35 illustrates a deck setup for 
FORTXCLG modified as follows : 

• A SYSIN DD statement defines the source 
module 

• A SYSIN DD statement defines input data 
to the load module 

• Job steps are modified as shown in the 
EXEC statement discussion in "Modifying 
EXEC Statements", example 4 (TIME in 
FORT, COND in LKED) 

• The SYSLMOD DD statement is modified as 
shown in the DD statement discussion 
above, example 1 

• Additional data sets to the load module 
are defined as shown in the DD 
statement discussion, example 3 

Note that all changes to a job step 
appearing earlier in the job processing 
sequence must be made before changes for 
later job steps. 



92 



r 

//TEST JOB ACCT3 , J. SMITH, MSGLEVEL=1 

//JOBLIB DD DSNAME=PRIV,DISP= (MOD, PASS) 

//ANY EXEC FORTXCLG, TIME* FORT=5, COND, LKED= ( 8, LT) 

//FORT.SYSIN DD * 

r t 

(Source module) 
l_ J 

/* 

//LKED. SYSLMOD DD DSNAME=PRIV(PROG) , DISP= (MOD, PASS ) 

//GO.FT10F001 DD DSNAME=DSET1, DISP=( NEW, DELETE) , VOLUME=SER=T1132, 

// UNIT=TAPE 

//GO. FT15F001 DD DSNAME=DSET2,DISP=( , DELETE) 8 VOLUME=SER=DA4 5, 

// UNIT=2311,SPACE=(TRK, (10,10)) 



r 1 

| Load module input | 

l J 

/* 
Figure 1-35. Submitting Modifications to a Cataloged Procedure 



IBM-Supplied Cataloged Procedures 93 



PART II — JOB OUTPUT 



IBM-Supplied Cataloged Procedures 95 



JOB OUTPUT 



Part II describes job step output for the 
FORTRAN program depicted in Figures II -1 
and II-2. Figure II-l shows a program as 
coded. Figure II- 2 shows the program as 



keypunched; keypunch errors have been 
introduced on purpose to provide instances 
of system diagnostic action. 



BM " WTWUI T" *" 

"nrmm SAMPLE PROGRAM """""' 








«o.l 


» 1 


NOGUMMil I * / ■■^rf 

" ».hmini | FOUTRAN 


TATEMENT 


IDCNIWCATION 
SCQUfNCf 


TTT-TTv'. • ' * '!" " " ' s 


feER P 


ftOBLE 


M 












~"~ " ■TYTT] FT 


~\~~\ f~ 


" 100 WRITE! i(6k 


8); 
















f ! ' 1 r ! 




8 FORMAT (5 


2H FO 


LL0WI 


NG IS 


A LI 


ST OF 


PRIM 


E HUM 


BERS' 


FROM 1 tO 1000/ 




~~~TlI*XilH!l/i 


9)MH 


2/19X 


>1H3) 













'! ;. M 


1 ! 


"Mli i-5,i! 
















i 


i j 


"Tlp'A^QRlTO 


— 


— 







., 


_ 






! ' 


i 






; 1 . } — i-j-4-J — F — Fp-(_ 




i g a J* A _ i 






















lg4 DO 1 K = 3! 7 


■b|2 
















, 1 i..i . F 




135 L-I/K 


















F : ■ i : 'i F ! 


+- 


~ 1(6 IF(L*K-I) 


1 » 2 »;<+ 














, 


4-1 . ■-+ i i ■ i F i 




"" 1 CONTINUE 


















' 




Ijj7 WRITS i(.t>> 


5 fcr , 














l 






5 -ORMAT (I 


2#) 










j 




— i i— 


: ! 


! 1 


2 ?b?+LL 


»j ' 














I 




-i- 4- - 


iirittiip^FT 


)rW* 


3 












. 


; 1 f ! Ml 




U WRITE (6' 


9) 
















i : F ! -M. 




9 TOM AT (1 


4Hi PR 


DGRAM 


ERRO 


R) 








^_ 




II i 




7 iVJRITE (6* 


^i 










! 




6 FOlRWAT jC3 


1H! TH 


IS IS 


THE 


END 


F THE 


PROG 


RAM) 


i 




i 


iLno IcTiniD I 1 I 

*n T •'I'M', i i i 












! 


1 


i i 


I ■ i ! 
. i 1 1 




EjNd i". 






















MM ! 1 ; ' ' 
























1 
















I ! , ', \ \ \ 


j i 


," } ) 4 ) i J « t io M 12 13 14 IS 16 17 11 19 20 7\ 77 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 63 66 67 61 *f 70 71 77 


73 74 75 74 77 7$ 7* » 


•A MM «m4 »•"». I8M •!«*• 888157. .» «.*M>U (o. p^K.n, *««•««*. (,«, *., t Q ,m 





Figure II-l. Sample Program as Coded 



Job Output 97 



r 

C PRIME NUMBER PROBLEM 

100 WRITE (6,8) 

8 FORMAT (52H FOLLOWING IS A LIST OF PRIME NUMBERS FROM 1 TO 1000/ 
119X, 1H1/19X, 1H2/19X, 1H3) 

101 1=5 

3 A=I 

102 A=SQRT(A) 

103 J=A 

104 DO I K=3,J,2 

105 L=I/K 

106 IF (L*K-I)1,2,4 
CONTINUE 

1 CONTINUE 

107 WRITE (3,5) I 

5 FORMAT (120) 

2 1=1+2 

108 IF (1000-1)7,4,3 

4 WRITE (6,9) 

9 FORMAT (14H PROGRAM ERROR) 
7 WRITE (6,6) 

6 FORMAT (31H THIS IS THE END OF THE PROGRAM) 

109 STOP 
END 

Figure II- 2. Sample Program as Keypunched 



98 



COMPILER OUTPUT 



Each compilation produces the following: 

• Informative messages letting the 
programmer know the status of the 
compilation 

• Any diagnostic messages generated 
during the compilation 

» Output as determined by the options 
selected by the programmer, either 
explicitly or by default 



The programmer may request the compiler 
options he wishes to exercise through the 
PARM parameter of the EXEC statement, or he 
may permit default options to govern 
compiler output. 



Figure II- 3 shows the sequence in which 
output from compiler options is printed. 



In addition to the options shown in 
Figure II-3 f the programmer may request the 
DECK option, which produces no listing, but 
generates a card deck of the object module. 



COMPILER OUTPUT WITH DEFAULT OPTIONS 



Default options cause the compiler to 
produce informative messages, diagnostic 
messages, compia.er statxstics, snu a 
listing of the source module. Figure II-4 
shows a printout for the FORTRAN program 
illustrated in Figure II- 2. 



Informative Messages 



The first line of a compilation output 
listing (Figure II-4, A) states the release 
level number of the compiler, the 
compiler's name, and the date of the run 
shown in the format 

year. date/hour. minute. second. 

Date information in Figure II-4 is shown as 
70. 002/12. 04. 4, indicating the year 1970, 
the second day of the year, and the time of 
the day the job was completed, 12:04.4 
(based on a 24-hour clock). 



r t n 

Option | Produces | 

|. + ) 



SOURCE* 

XREF 

LIST 

FORMAT 
LIST 



Informative messages 

Source module listing 

Cross-reference listing 

Object module listing: 

Part I: Entry code, constants, external address constants 



Edited source module listing 

Object module listing: 

Part II: Executable instructions, internal address constants 

MAP | Source module map 

Diagnostic messages 

Compiler statistics 
V x 

| *Specified as default option in cataloged procedures. 

L 

Figure II- 3. Compiler Printed Output Format 



Compiler Output 99 



1 C MAR 71 ) 



MAIN 



OS/360 FORTRAN H EXTENDED 



DATE 71.057/09.59.01 



© 



REQUESTED OPTIONS: NODECK ,NCL 1ST ,OPT=C 



OPTIONS IN EFFECT: NAME( MA IN ) ,NOOPT I M I Z E, L INECOUNT < 6C ) , SI ZE < MAX ) , AUTODBL ( NONE) , 

SOURCE,EeCCIC,NOLIST,NODECK,CBJECT,NOMAP,NOFORMAT, NOGOSTMT ,NOXREF , NOALC .NOANSF ,F LAG < I ) 



1 TO 10CC/ 





C 


PRIME NUMEER PROBLEM 


ISN CCC2 


ICC 


WRITE (6,8) 


ISN CCC3 


8 


FORMAT (52H FOLLOWING IS A LIST OF PRIME M 




119X,1H1/19X,1H2/19X,1H3) 


ISN COCA 


101 


1 = 5 


ISN CCC5 


3 


A=I 


ISN 00C6 


102 


A=SQRT( A) 


ISN C007 


103 


J=A 


ISN CCC8 


104 


DO 1 K=3,J,2 


ISN CCC9 


105 


L = I/K 


ISN CC1C 


106 


IF( L*K-I )1,2,4 


ISN COll 




CONTINUE 


ISN CC12 


1 


CONTINUE 


ISN 0013 


107 


WRITE(3,5) I 


ISN C014 


5 


FORMAT (I2C) 


ISN CC15 


2 


1 = 1 + 2 


ISN CC16 


108 


IF(1CCC-I)7,4,3 


ISN C017 


4 


WRITE (6,9) 


ISN C018 


9 


FORMAT (14H PROGRAM ERROR) 


ISN CC19 


7 


WRITE (6,6) 


ISN CC2C 


6 


FORMAT (31H THIS IS THE END OF THE PROGRAM 


ISN CC21 


1C9 


STOP 


ISN CC22 




END 



( NUMBER LEVEL 
fy \ IFE224I 8(E) 



ISN 
ISN 



CC11 
0011 



FORTRAN H EXTENDED ERROR MESSAGES 

THE STATEMENT AFTER AN ARITHMETIC IF, GO TO, OR RETURN HAS NC LABEL. 
THE CONTINUE STATEMENT DOES NOT HAVE A STATEMENT NUMBER. 



IFE2G8I 4<W) 

♦OPTIONS IN EFFECT*NAME< MAIN ) , NOOPT IMI ZE , L I NECCUNT< 60 ) , SI ZE < M AX ) , AUTCCBH NONE ) , 

^OPTIONS IN EFFECT*SOURCE, EBCDIC, NOLI ST, NODECK, OBJECT, NOM AP ,NOFORMAT , NOGOSTMT, NOXREF, NOALC, NOANSF, FLAG ( I) 

^STATISTICS* SOURCE STATEMENTS = 21, PROGRAM SIZE = 706, SUBPROGRAM NAME = MAIN 

♦STATISTICS* 2 DIAGNOSTICS GENERATED, HIGHEST SEVERITY CODE IS 8 

****** END OF COMPILATION ****** 1C5K BYTES OF CORE NOT USED 



Figure 11-4. Compiler Output from Default Options 



The second line (and a third line, if 
needed) shows the compiler options current 
at the time of job submission (Figure II-4, 
B). 



At the end of the listing, compiler 
statistics are printed (Figure II-4, E) 
listing all current options, the number of 
statements in the source module, the source 



module size in decimal, and the number and 
severity of diagnostic messages. 



The last entry of a compilation is the 
informative message: 

******END OF COMPILATION****** 



100 



Diagnostic Messages 



Source Listing 



Compiler diagnostic messages are assigned 
severitv codes as follows; 



Severity 
Code 



12 



Meaning 

Indicates an informational 
message; messages with a 
severity code act as notes to 
the programmer 



Is a warning message code; 
usually, a minor error,- which 
does not violate the syntax of 
the FORTRAN IV language was 
detected 



Is an error message code; 
usually, an error which 
violates FORTRAN IV syntax was 
detected. The compiler 
attempts to make a corrective 
assumption. 

Is a serious error message 
code; an error which violates 
FORTRAN IV syntax and for which 
the compiler could make no 
corrective assumption was 
detected 

Is an abnormal termination 
message code; an error which 
prevents the compiler from 
continuing program processing 
was detected 



Messages with severity code 4 permit the 
compiled object module to be passed to the 
link edit step. Severity levels higher 
than level 4 prevent link edit processing, 
unless the programmer has increased the 
permissible condition code in the COND 
parameter of the compilation EXEC 
statement. 

Diagnostic messages in Figure II-4 are 
marked D. Messages display the call 
letters IFE identifying the FORTRAN IV 
(H Extended) compiler, an internal 
statement number developed from the 
original source statement, the severity 
code, and explanatory text. In Figure 
II-4, two diagnostic messages were 
generated by statement 11, an extraneous 
CONTINUE statement. 



16 



The source listing in Figure II-4 is marked 
C. Source listing statements are identical 
to the original statements submitted in the 
FORTRAN program, except for the addition of 
internal sequence numbers <ISN), 



COMPILER OUTPUT WITH PROGRAMMER-SPECIFIED 
OPTIONS 



The compiler always produces informative 
and diagnostic messages. The programmer 
may suppress the source listing by 
specifying NOSOURCE and may also choose to 
generate other forms of output. 

Figures II-5 and II-6 show additional 
output for the program illustrated in 
Figure II-2. Figure II-5 illustrates the 
following: 

1. A cross-reference listing 

2. An object module listing 

3. An edited source module listing 

4. A source module map 

Figure II- 6 shows the deck setup of an 
object card deck. 



Cross-Reference Listing 



The programmer requests a cross-reference 
listing by specifying the compiler option 
XREF and a DD statement named SYSUT2. The 
cross-reference listing in Figure II- 5 is 
marked A. 

A cross-reference listing shows the 
symbols and statement labels in the source 
module together with the internal statement 
numbers in which they appear. Symbols 
(which define variables) are listed by 
name, according to length, in alphabetic 
order, beginning with names one character 
long. Statement labels are listed in 
ascending order and display each internal 
sequence number (ISN) in which they are 
referenced. 



Compiler Output 101 



L<=VEL 1 ( MAR 71 ) 



MAIN 



OS/360 FORTRAN H EXTENDED 



DATE 71.062/21.06.** 



• FORTRAN 



***** 

INTERNAL STATEMENT NUMBERS 
00 05 0006 0006 0007 

0012 



CROSS 





00 0* 


0005 


0009 001 




00 07 


0008 






00 08 


0009 


0010 




00 C9 


0010 




RT 


00 06 












*****F 


ABEL 


OEF INED 


REFERENCES 


1 


0011 




0008 0010 


2 


001* 




0010 


3 


0005 




0015 


* 


0016 




0010 0015 


5 


0013 




0012 


6 


0019 




0018 


7 


0018 




0015 


8 


00 3 




0002 


9 


0C17 




0016 


100 


0002 






101 


000* 






102 


0006 






103 


007 






10* 


0008 






105 


0009 






106 


0010 






107 


0012 






108 


0015 






109 


0020 







001* 001* 0015 



R T R A N 



REFERENCE 



Rt FERENCE 



LISTING" 



LISTING* 



o 







e 



OCCOCC 


*7 


FC 


F 


ooc 


OOOOC* 


07 








000005 


D*C1C9D5* 0*0*0 


oooooc 


90 


EC 





ooc 


cocoio 


98 


23 


F 


020 


00001* 


50 


30 


D 


08 


000018 


50 


DO 


3 


00* 


ooooic 


07 


F2 






TEMPORARY FOR FIX/FLOAT 










00 1 


OOOCOOOO 


00010* 


00000000 


000108 


*EOCOOOO 


0001CC 


00000000 


CONSTANTS 










000110 


*F080000 


00011* 


00000000 


000118 


*E0O0OOO 


00011C 


80000000 


000120 


00000002 


00012* 


00000003 


000128 


00000 0C5 


00012C 


000003E8 


AOCONS FOR VARIABLES AND CONSTANTS 




ADCONS FOR EXTERNAL REFERENCES 






0001*8 


OCOOOOOO 


0CC1*C 


00000000 


000178 


58 


FO 


D 


9C 


0C017C 


*5 


EC 


F 


CO* 


000180 


00000006 


00018* 


00000028 


000188 


*5 


EO 


F 


010 


00018C 


58 


00 


D 


078 


000190 


50 


00 


D 


08* 


00019* 


58 


OC 


D 


8* 


C00198 


5C 


00 


D 


05C 


C0019C 


97 


80 


D 


05C 


0001AO 


68 


00 


D 


058 


0C01A* 


6B 


00 


D 


068 


0001A8 


70 


CO 


D 


080 


0001AC 


*1 


10 





0*C 


0001BO 


58 


FO 


D 


C98 


0001B* 


05 


EF 






0001B6 


70 


00 


D 


OAO 


0CC1BA 


78 


00 


D 


OAO 


0001BE 


70 


CO 


D 


080 


C001C2 


2B 


00 






0C01C* 


78 


00 


.0 


80 


0001C8 


6A 


CO 





060 


0001CC 


60 


00 


D 


05C 


0001D0 


58 


00 


D 


05* 


0001D* 


50 


00 


D 


088 


0001D8 


58 


00 


D 


07* 


0001DC 


50 


00 


D 


08C 


0001EO 


58 


00 


b 


8* 


0001E* 


8E 


00 





020 


0001E8 


5D 


00 





OBC 


0001 EC 


50 


10 


D 


090 


0O01F0 


58 


10 





8C 


0001F* 


5C 


00 


D 


090 



BC 


15, 


12(0, 


L5) 


OC 


XL1 


07' 




DC 


CL7 


MAIN 


' 


STM 


1*. 


L2, 12(13) 


LM 


2,3 


32(15) 


ST 


3,8(13) 




ST 


13,4(0,3) 


BCR 


15, 


I 




OC 


XL* 


00 000000" 


DC 


XL* 


OOOOOOCO' 


DC 


XL* 


*E0O0COO' 


DC 


XL* 


00000000" 


OC 


XL* 


*F 080000" 


OC 


XL* 


00 000000' 


DC 


XL* 


*E 000000" 


DC 


XL* 


80000000' 


DC 


XL* 


00000002" 


DC 


XL* 


00000003" 


DC 


XL* 


0000O0C5' 


DC 


XL* 


000003E8' 


DC 


XL* 


00000000" 


DC 


XL* 


OOOOOOOC" 


L 


15, 


156( 


0,13) 


BAL 


1*, 


*( 


0,15) 


DC 


XL* 


00000006' 


DC 


XL* 


00000028" 


BAL 


1*, 


161 


0,15) 


L 


0, 


1201 


0,131 


ST 


0, 


1321 


0,13) 


L 


C, 


132( 


0,13) 


ST 


0, 


921 


0,13) 


XI 


92(13) 


,128 


LD 


0, 


88( 


0,13) 


SD 


0, 


10*( 


0,13) 


STE 


0, 


128( 


0,13) 


LA 


1, 


76( 


0,13) 


L 


15, 


152( 


0,13) 


BALR 


1*> 


15 




STE 


0, 


160( 


0,13) 


LE 


0, 


1601 


0,13) 


STE 


0, 


128( 


0,131 


SDR 


0, 







LE 


0, 


1281 


C13) 


AD 


0, 


96( 


0,13) 


STD 


0, 


80( 


0,13) 


L 


0, 


8*( 


0,13) 


ST 


0, 


136( 


0,13) 


L 


0, 


116( 


0,13) 


ST 


0, 


l*0f 


0,13> 


L 


0, 


1321 


0,13) 


SRDA 


0, 


32 







0, 


1*0( 


0,13) 


ST 


1, 


1**( 


0,13) 


L 


1, 


1*0( 


0,13) 


M 


0, 


!**( 


0,13) 



SQRT 
IBCOM# 
IBCOM# 



*EOO0 00080000000 



*F0800000000000C 



Figure II-5. Compiler Output from Programmer-Specified Options 
(Part 1 of 3) 



102 



© 



0001F8 


5B 


10 


D 084 


0001FC 


58 


50 


D OBC 


000200 


07 


95 




000202 


58 


50 


D OCO 


000206 


07 


25 




CC0208 


58 


00 


D 8C 


00020C 


5A 


00 


D 070 


000214 


59 


00 


D 088 


000218 


58 


50 


D OBO 


00021C 


07 


D5 




00021E 


58 


FO 


D 09C 


000222 


18 


00 




000224 


45 


EO 


F 004 


000228 


000 00003 


00022C 


00000072 


000230 


45 


EO 


F 08 


000234 


0450D084 


000238 


45 


EO 


F 010 


00023C 


58 


00 


D 084 


000240 


5A 


00 


D 070 


000244 


50 


00 


D 084 


000248 


58 


00 


D 07C 


00024C 


5B 


00 


D 084 


000250 


58 


50 


D 0C4 


000254 


07 


45 




000256 


58 


50 


D OCO 


00025A 


07 


95 




00025C 


58 


50 


D OAC 


000260 


07 


25 




000262 


58 


FO 


D 09C 


000266 


18 


00 




000268 


45 


EO 


F 004 


00026C 


00000006 


000270 


00000076 


000274 


45 


EO 


F 010 


000278 


58 


FO 


D 09C 


00027C 


45 


EO 


F 004 


. 000280 


00000006 


1 000284 


00000088 


000288 


45 


EO 


F 010 


00028C 


58 


FO 


D 09C 


000290 


45 


EO 


F 034 


000294 


05 






000295 


40 






000296 


40 






000297 


40 






000298 


40 






000299 


FO 






ADDRESS OF EPILOGJE 








00029A 


58 


FO 


D 09C 


00029E 


45 


EO 


F 034 


0002A2 


0540 




0002A4 


4C4040FO 


Huurscoo ur ruLUuuc 








0002AA 


58 


FO 


3 09C 


0002AE 


45 


EO 


F 040 


0002B2 


18 


D3 




0002B4 


58 


FO 


D 0A8 


0002B8 


07 


FF 




ADCON FOR PROLOGUE 








000020 


000002AA 


ADCON FOR SAVE AREA 








000024 


OOOOOOBO 


ADCON FOR EPILOGUE 








OOOOBO 


0000029A 


ADCONS FOR PARAMETER LISTS 








000OFC 


80000130 


TEMPORARIES AND GENERATED 


CONSTANTS 


000150 


00000000 


000154 


00000000 


ADCONS FOR B BLOCK LABELS 








000158 


00000178 


00015C 


00000194 


000160 


000001E0 


000164 


00000208 


000168 


0000021E 


00016C 


0000023C 


000170 


00000262 


000174 


00000278 



107 



108 



109 



s 


It 


132( 


0,13) 


L 


5, 


188( 


0,13) 


BCR 


9, 


5 




L 


5, 


192( 


0,13) 


BCR 


2, 


5 




L 


0, 


140( 


0,13) 


A 


0, 


112( 


0,13) 


O I 


U f 


140 ( 


u , i -5 i 


c 


0, 


136( 


0,13) 


L 


5, 


176( 


0,13) 


BCR 


13, 


5 




L 


15, 


156( 


0,13) 


LR 


0, 







BAL 


14, 


4( 


0,15) 


DC 


XL 4 


00000003' 


DC 


XL 4 


00000072" 


BAL 


14, 


8( 


0,15) 


DC 


XL4 


0450D084' 


BAL 


14, 


16( 


0,15) 


L 


0, 


132( 


0,13) 


A 


0, 


1121 


0,13) 


ST 


0, 


132( 


0,13) 


L 


0, 


124( 


0,13) 


S 


0, 


132( 


0,13) 


L 


5, 


196( 


0,13) 


BCR 


4, 


5 




L 


5, 


192( 


0,13) 


BCR 


9, 


5 




L 


5, 


172( 


0,13) 


BCR 


2, 


5 




L 


15, 


156( 


0,13) 


LR 


0, 







BAL 


14, 


4( 


0,15) 


DC 


XL 4" 


00000006' 


DC 


XL 4 


00000076' 


BAL 


14, 


16( 


0,15) 


L 


15, 


156( 


0,13) 


BAL 


14, 


4( 


0,15) 


DC 


XL4 


00 000006' 


DC 


XL4 


00000088' 


BAL 


14, 


16( 


0,15) 


L 


15, 


156( 


0,13) 


BAL 


14, 


52( 


0,15) 


DC 


XL1 


05' 




DC 


XL1' 


40 « 




DC 


XL1 


40" 




DC 


XL1 


40' 




DC 


XL1 


40' 




DC 


XL1 


FO' 




L 


15, 


156( 


0,13) 


BAL 


14, 


52( 


0,15) 


DC 


XL 2' 


0540 




DC 


XL4 


404040F0' 


L 


15, 


156( 


0, 3) 


BAL 


14, 


64( 


0,15) 


LR 


13, 


3 




L 


15, 


16 8(. 


0,13) 


BCR 


15, 


L5 




DC 


XL4 


000002AA' 


DC 


XL4 


OOOOOOBO' 


DC 


XL 4 


0000029A' 


DC 


XL4 


80000130' 


DC 


XL4 


00 000000' 


DC 


XL 4 


00 000000' 


DC 


XL4 


0J000178' 


DC 


XL 4 


00 000194' 


DC 


XL4 


000001E0' 


DC 


XL4 


00000208' 


DC 


XL4 


0C00021E' 


DC 


XL4 


0000023C 


DC 


XL4 


00000262' 


DC 


XL4 


00000278' 



J 

105 



!BCOM# 



I 

I 

2 

I 

1000 

I 

7 
4 
3 

IBCOM# 



IBCOM# 
6 

IBCOM# 



IBCOM# 



IBCOM# 



Figure II-5. Compiler Output from Programmer-Specified Options (Part 2 of 3) 



Compiler output 103 



o 



(002 



002 ) 







/ STRUCTURED SOURCE LISTING / 






C PRIME NUMBER PROBLEM 


ISN 0002 


100 


WRITE (6,8) 


ISN 0003 


8 


FORMAT (52H FOLLOWING IS A LIST OF PRIME NUMBERS FROM 1 




119X,1H1/19X,1H2/19X,1H3) 


ISN 0004 


101 


1 = 5 


ISN 0005 


3 


A = I 


ISN 0006 


102 


A=SQRT( A) 


ISN 0C07 


103 


J = A 


ISN 0008 


104 


00 1 K=3,J,2 


ISN 0009 


105 


L = I/K 


ISN 0010 


106 


IF( L*K-I ) 1,2,4 


ISN 0011 


1 


CONTINUE 


ISN 00 12 


107 


WRITE (3,5)1 


ISN 0013 


5 


FORMAT (120) 

C 

1=1 + 2 


ISN 0014 


2 


ISN 0015 


108 


IF(1000-I)7,4,3 


ISN 0016 


4 


WRITE (6,9) 


ISN 0017 


9 


FORMAT (14H PROGRAM ERROR) 

C 

WRITE (6,6) 


ISN 0018 


7 


ISN 0019 


6 


FORMAT (31H THIS IS THE END OF THE PROGRAM) 


ISN 00 20 


109 


STOP 


ISN 0021 




END 



MAIN / 



SIZE OF PROGRAM 0002BA HEXADECIMAL BYTES 



MAME 


TAG 


TYPE 


ADD. 


NAME 


TAG 


TYPE 


ADD. 


NAME 


TAG 


TYPE 


ADD. 


NAME TAG 


TYPE 


ADD. 


A 


SFA 


R*4 


000130 


I 


SF 


1*4 


000134 


J 


SF 


1*4 


000138 


K SF 


1*4 


00013 


L 


S 


I *4 


000140 


SQRT 


F XF 


R*4 


000000 


I BCOM# 


F XF 




000000 









S3URCE STATEMENT LABELS 

LABEL ISN ADDR 

100 2 000178 NR 

103 7 0001C2 NR 

1 11 000208 

4 16 000262 

COMPILER GENERATED LABELS 

LABEL ISN ADDR 
100000 1 000178 

FORMAT STATEMENT LABELS 



LABEL ISN ADDR 

101 4 00018C NR 

104 8 0001D8 NR 

107 12 00021E 

7 18 000278 



LABEL ISN 



LABEL 


ISN 


ADDR 




LABEL 


ISN 


ADDR 




3 


5 


000194 




102 


6 


0001AC 


NR 


105 


9 


0001 EO 




106 


10 


0001F0 


NR 


2 


14 


000 2 3C 




108 


15 


000248 


NR 


109 


20 


00028C 


NR 










LABEL 


ISN 


ADDR 




LABEL 


ISN 


ADDR 





ISN 


ADDR 


LABEL 


ISN 


ADDR 


LABEL 


ISN 


ADDR 


3 


0C0028 


5 


13 


000072 


9 


17 


000076 



LABEL ISN ADDR 
6 19 000088 



Figure II-5. Compiler Output from Programmer-Specified Options (Part 3 of 3) 



Object Module Listing 



The programmer requests an object module 
listing by specifying the option LIST. The 
object module listing in Figure II-5 is 
marked B. 



An object module listing is in an 
assembler language format showing each 
assembler language instruction. The 
listing is arranged as follows: 



• The first column, labeled 1, indicates 
the relative address of the instruction 
in hexadecimal format. 

• The columns labeled 2 indicate the 
storage representation of the 
instruction in hexadecimal format. 

• The column labeled 3 indicates 
statement numbers, which may be either 
those appearing in the source program 
or those generated by the compiler 
(compiler-generated numbers contain six 
digits) . 



104 



• The columns labeled 4 indicate the 
pseudo-assembler language format for 
each statement. 

• The column labeled 5 indicates any 
significant items referred to by the 
instruction, such as entry points of 
subprograms or other statement numbers, 



Edited Source Module Listing 



The programmer requests an edited source 
module listing by specifying the options 
FORMAT and OPTIMIZE*. 2) and by including a 
DD statement named SYSUT1. The edited 
source module listing in Figure II-5 is 
marked C. 

This listing is independent of the usual 
source listing; it indicates the loop 
structure and logical continuity of the 
source program. 

Each loop is assigned a unique 3-digit 
number. Entrance to the loop is indicated 
by a left parenthesis followed by a 3-digit 
number; exit from the loop is indicated by 
the 3-digit number followed by a right 
parenthesis on a separate line before the 
next non- comment line. 

Indentions are used to show dominance 
relationships among executable source 
statements. Statement A dominates 
statement B if A is the last statement 
common to all logical paths from which B 
receives control. Statement A is called a 
dominator, statement B is called a dominee. 
By this definition, a statement can have 
only one dominator, but a dominator may 
have several dominees. For example, a 
computed GO TO statement is the last 
statement through which control passes 
before reaching three other statements. 
The GO TO statement is a dominator with 
three dominees. 

A dominee is indented from its dominator 
unless it is either the only dominee or the 
last dominee of that dominator. The line 
of sight between a dominator and its 
dominee (s) may be obscured by intervening 
statements. This is a dominance 

discontinuity and is indicated by C on a 

separate line above the dominee. 

Comments and non-executable statements 
are not involved in dominance 
relationships; their presence never causes 
a dominance discontinuity. Comments are 
aligned with the last preceding non-comment 
line; nonexecutable statements are aligned 
either with the last preceding executable 
statement or with the first one following. 



The edited source module listing in 
Figure II- 5 shows two loops; loop 001 is 
nested within loop 002. 



Source Modu le Map 



The programmer requests a storage map by 
specifying the option MAP. The source 
module map in Figure II— 5 is marked D. 

A map indicates the use made of each 
number within a program. 

The first line of a map gives the name 
and size of the program. The size is noted 
in hexadecimal format. 

The column headed NAME indicates the 
name of each variable, statement function, 
subprogram, or implicit function. 

The column headed TAG indicates use 
codes for each name and variable. Use 
codes are the following: 

1. The letter S for a variable appearing 
to the left of an equal sign; i.e., a 
variable whose value was stored during 
some operation 

2. The letter F for a variable appearing 
to the right of an equal sign; i.e., a 
variable whose value was manipulated 
during some operation 

3. The letter A for a variable used as an 
argument in a parameter list 

4. The letter C for a variable in a 
COMMON block 

5. The letter E for a variable in an 
EQUIVALENCE block 

6. The letters -ASF for an arithmetic 
statement function 

7. The letters XF for an external 
function 

8. The letters XR for an external 
reference to an array, variable, or 
subprogram that is referenced by name. 

9. The letter D for a promoted (doubled) 
variable 

10. The letter P for a padded variable 

11. An asterisk (*) for a promoted library 
function 

Note that the combination code ASF should 
not be confused with the individual codes 
A, S, and F. The individual codes print 



Compiler Output 105 



out in the order SFA while the arithmetic 
function code always prints as ASF. 

The column headed TYPE indicates the 
type and length of each variable. 

The column headed ADD indicates the 
relative address assigned to a name. 
(Functions, arithmetic statement function, 
subroutines, and external references have a 
relative address of 00000. ) For 
non- referenced variables, this column 
contains the letters NR instead of a 
relative address. 

The MAP option also produces a table of 
statement numbers known as a label map 
(marked E in Figure II-5). The label map 
shows each statement number from the source 
statement, from compiler generated labels, 
and from FORMAT statements, the relative 
address assigned to each statement, and the 
symbol NR for each statement that is not 
referenced. 

If the source module contains COMMON or 
EQUIVALENCE statements, the MAP option also 
produces a storage map for each COMMON and 
EQUIVALENCE block. Because the sample 
program in Figure II-l contained no COMMON 
or EQUIVALENCE statement, no such storage 
map is illustrated in Figure II-5. Figure 
II-7 illustrates a section of another 
program and the resulting storage map. The 
map for a COMMON block contains the same 
kind of information as for the main 
program. Any variable equivalenced to a 
variable in COMMON is listed along with its 
displacement (offset) from the beginning of 
the block. 



Object Module Deck 



The programmer requests an object module 
deck by specifying the compiler option 
DECK. Figure II- 6 shows a typical layout 
of an object deck. 

The object deck may be used as input to 
the linkage editor in a later job. The 
deck is a copy of the object module which 
consists of dictionaries, text, and an 
end-of -module indicator. Object modules 
are described in greater detail in the 
appropriate linkage editor and loader 
publication, as listed in the Preface. 

The object deck consists of four types 
of cards identified by the characters ESD, 
RLD, TXT, or END in columns 2 through 4. 
Column 1 of each card contains a 12-2-9 
punch. Columns 73 through 80 contain the 
first four characters of the program name 
followed by a four-digit sequence number. 
The remainder of the card contains program 
information. 



ESD CARD : ESD cards describe the entries 
of the External Symbol Dictionary , which 
contains one entry for each external symbol 
defined or referred to within a module. 
For example, if program MAIN calls 
subprogram SUBA, the symbol SUBA will 
appear as an entry in the External Symbol 
Dictionaries of both the program MAIN and 
the subprogram SUBA. The linkage editor 
matches the entries in the dictionary to 
the entries in the dictionaries of other 
included subprograms and, when necessary, 
to the automatic call library. 

ESD cards are divided into four types, 
identified by the digits 0, 1, 2, or 5 in 
column 25 of the first entry in the card, 
column 41 if a second entry, and column 57 
if a third entry (there can be 1, 2, or 3 
external-symbol entries in a card). 



ESD 

Typ e 





Contents 
Name of the program or 
subprogram and indicates the 
beginning of the module. 

Entry point name appearing in 
an ENTRY statement of a 
subprogram. 

Name of a subprogram referred 
to by the source module 
through CALL statements, 
EXTERNAL statements, and 
explicit and implicit 
function references (Some 
usages of FORTRAN are of such 
complexity, that a function 
subprogram is called in place 
of in-line coding. Such 
calls are called im pl icit 
function refe ren ce s ) . 

Information about a COMMON 
block. 



TXT CARD; TXT cards contain the constants 
and variables used by the programmer in his 
source module, any constants and variables 
generated by the compiler, coded 
information for FORMAT statements, and the 
machine instructions generated by the 
compiler from the source module. 



RLD CARD; RLD cards describe entries in 
the Relocation Dictionary, which contains 
one entry for each address that must be 
resolved before a module can be executed. 
The Relocation Dictionary contains 
information that enables absolute storage 
addresses to be established when a module 
is loaded into main storage for execution. 
These addresses cannot be determined 
earlier because the starting address of a 
module is not known until the module is 



106 



loaded. The linkage editor consolidates 
RLD entries in the input modules into a 
sinqle relocation dictionary when it 
creates a load module. 



RLD cards contain the storage address of 
subprograms called by ESD type 2 cards. 



gym \-t\nv i me lhu udiu znaiccrces : 

1. The end of the object module to the 
linkage editor, 

2. The relative location of the main 
entry point, and 

3. The length (in bytes) of the object 
module. 



ESD, Type 2, and 
RLD for External 
References in 
CALL, EXTERNAL, 
and Statement* 
Using Subprograms 




Figure II- 6. Object Module Deck Structure 



1SN 


0002 


C 
C 
C 
C 
C 
C 
C 


ISN 


0003 




ISN 


0004 




ISN 


0005 




ISN 


0006 




ISN 


0007 




ISN 


0008 




ISN 


0009 




ISN 


0010 





SUBROUTINE P03Vl;C ( P, T) 

;;;:;k;:5!!s« TH IS SUBROUTINE COMPUTES AND PRINTS 
:sk!:«5cks::: EIGENVALUES, CUMULATIVE PROPORTIONS OF TOTAL 
;:«::::ssi:ssss VARIANCES AND POSITIVE EIGENVECTORS. 



INTEGER P, T 

COMMON / SHARE1 / EIGVECC80, 80) 

COMMON / SHARED / CUMPROC80) 

COMMON / VALUE / EIGVALC80) 

DIMENSION POSVEX(80,80), POSVALC80) 

EQUIVALENCE (EIGVECCl, D, POSVEXCl, D) 

EQUIVALENCE (EIGVALCD, POSVAL(D) 

CALL EIGEN ( P ) 



NAME TAG 

I SF 

EIGEN SF XF 

IBCOMtt F XF 

POSVEX F CE 



TYPE 

R»4 
R !! 4 



ADD. 

000180 

000000 

000000 

000000 



NAME 

J SF 
CUMPRO SF 
IBERHH 



C 
XF 



/ POSVEC / 

TYPE ADD. 
1*4 0001B4 
R»4 000000 
I !: 4 N.R. 



SIZE OF PROGRAM 000478 HEXADECIMAL BYTES 



NAME TAG 
P SFA 
EIGVAL F CE 
POSVAL F CE 



TYPE 
I -4 
R"<t 
R«4 



ADD. 
0001B8 
000000 
000000 



NAME OF COMMON BLOCK 



VAR. NAME 
EIGVEC 



TYPE 
R*4 



REL. ADDR 
000000 



-SHARE 1" 

VAR. 



***** COMMON INFORMATION ***** 

SIZE OF BLOCK 006400 HEXADECIMAL BYTES 

NAME TYPE REL. ADDR. VAR. NAME TYPE REL. ADDR. 



EQUIVALENCED VARIABLES WITHIN THIS COMMON BLOCK 
VARIABLE OFFSET VARIABLE OFFSET 

POSVEX 000000 



VARIABLE OFFSET 



NAME OF COMMON BLOCK 



VAR. NAME TYPE 
CUMPRO R*4 



REL. ADDR. 
000000 



SHARE4* 

VAR. 



NAME OF COMMON BLOCK 



VAR. NAME TYPE 
EIGVAL R*4 



REL. ADDR. 
000000 



VALUE" 
VAR. 



SIZE OF BLOCK 000140 HEXADECIMAL BYTES 

NAME TYPE REL. ADDR. VAR. NAME TYPE REL. ADDR. 

SIZE OF BLOCK 000140 HEXADECIMAL BYTES 

NAME TYPE REL. ADDR. VAR. NAME TYPE REL. ADDR. 



EQUIVALENCED VARIABLES WITHIN THIS COMMON BLOCK 
VARIABLE OFFSET VARIABLE OFFSET 

POSVAL 000000 



VARIABLE OFFSET 



NAME TAG 
T SF 
EIGVEC CE 
POSVEC 



TYPE ADD. 

1*4 0001BC 

R*4 000000 

R*4 000100 



VAR. NAME TYPE REL. ADDR. 



VARIABLE OFFSET 



VAR. NAME TYPE REL. ADDR. 



VAR. NAME TYPE REL. ADDR. 



VARIABLE OFFSET 



Figure II-7. Source Statements and Storage Map for COMMON /EQUIVALENCE Blocks 



Compiler Output 107 



LINKAGE EDITOR AND LOADER OUTPUT 



As with compiler output, output from the 
link edit step depends upon the options in 
effect at the time of job submission. 



LINKAGE EDITOR OUTPUT 



The cataloged procedures calling the 
linkage editor specify the LET, LIST, and 
XREF options; the programmer may override 
or add to these options through the PARM 
parameter of the EXEC statement. 



A program unit (main program, 
subprogram, or COMMON block) is termed a 
control section in the link edit step. A 
control section may be the object module 
produced from the original source module, 
or it may be a module called by the linkage 
editor to perform such functions as 
input/output operations, interface with the 
operating system, or mathematical 
operations required by the program. 
Control sections called by the linkage 
editor are identified on the module map by 
the character * after the control section 
name (for example, IHOECOMH* in Figure 
II-8). 



LINKAGE EDITOR OUTPUT WITH 
PROCEDURE-SPECIFIED OPTIONS 



For the FORTRAN program illustrated in 
Figure II- 2, linkage editor output is shown 
in Figure II-8. Options current at the 
time of job submission are always listed 
(Figure II-8, A) followed by any printed 
output . 

The linkage editor combines a number of 
modules into one load module. The LET 
option marks the load module executable 
even though certain error conditions may 
have been detected. LET does not result in 
any printed output. 

LIST causes linkage editor control 
statements associated with the job step to 
be printed. No linkage editor control 
statements are shown in Figure II- 8. See 
the section "Linkage Editor Overlay 
Feature" for an example. 



Cross-Reference Table 



Unlike the compiler MAP and XREF options, 
which are mutually independent, the linkage 
editor XREF option produces both a module 
map and a cross-reference listing. If the 
programmer wants the only module map 
printed, he specifies MAP in place of XREF. 
The module map shows the name of each 
program unit, the relative location of its 
beginning point, its length, and any entry 
names to the program unit. The module map 
in Figure II-8 is labeled B. 



In Figure II-8, the control section MAIN 
begins at relative location 00 and has a 
length expressed in hexadecimal format of 
278 (equal to 632 bytes). The remaining 
control sections are those called from the 
FORTRAN library by the linkage editor. 
Control section IHOECOMH begins at location 
278 and has entry points named IBCOM, 
FDIOCS, and INTSWTCH. IBCOM is also the 
beginning point of the control section 
since it too begins at location 278; FDIOCS 
begins at location 334, and INSWTCH at 
location 1196. Control section IH0C0MH2 
contains only one entry point, SEQDASD, 
beginning at a location within the section. 



Following the map in Figure II-8 is the 
cross-reference table (labeled C) which 
lists the location of each reference within 
the load module, the symbol to which the 
reference refers, and the name of the 
control section in which the symbol is 
defined. 

If an overlay structure has been 
specified, a separate map and 
cross-reference listing is produced for 
each segment of the structure. See the 
section "Linkage Editor Overlay Feature" 
for an example. 

The total length of the load module is 
listed at the bottom of the cross-reference 
table. 

The message (Figure II-8, D) is not part 
of the module map; it is a disposition 
message issued by the linkage editor 
stating that MAIN has been added to a load 
module library. 



108 



F88-LEVEL LINKAGE EOITCR CPTICNS SPECIFIEC XREF, LET, L 1ST 
VARIABLE OPTIONS USEC - S IZE= (92160, 8192)- 



DEFALLT OPTICN(S) USED 



CROSS REFERENCE TABLE 



©~ 





CONTROL SECTION 




ENTRY 














NAME 


ORIGIN 


LENGTH 


NAME LCCATION 


NAME LCCATION 


NAME LOCATION NAME LCCATIC 




MAIN 


00 


278 
















IHCECCMH* 


278 


CC4 






















IBCOM# 


2A4 


FDICCS* 


360 


INTSWTCH 


1028 




IH0CCMH2* 


1040 


975 


SEQDASC 


13AA 












IHOSSQRT* 


1988 


168 


SORT 


19B8 


IHSSQRT 


19B8 








IHOFCVTH* 


1B20 


AC7 




















ADCON# 


1B20 


FCVACUTP 


1BCA 


FCVLCUTP 


1C5A FCVZOUTP 1CB6 








FCVIOUTP 


215A 


FCVEOUTP 


224C 


FCVCCUTP 


224C INT6SWCH 24A8 


^ IHOEFNTH* 

O 

^^ IHQEFIGS* 


2526 


7C8 


















ARITH# 


2528 


ACJSWTCH 


2A88 






2CF0 


10FC 




















FIOCS# 


2CF0 


FIOCSBEP 


2CF6 






IH0FI0S2* 


3CE0 


5AC 
















i IHOUOPT * 


4390 


318 
















IHOFCCNI* 


46A8 


2FD 


FCCONI# 


46A8 












IHOFCONO* 


49A8 


558 


FCCONC# 


49A8 












IHOERRM * 


4F0C 


5EC 


ERRMON 


4F00 


IFOERRE 


4F18 








IHOUATBL* 


54FC 


20 8 
















IHCFTEN * 


56F8 


198 


FTEN# 


56F8 












IHOETRCH* 


589C 


2A6 


















REFERS 


TO SYMBOL IN 


IHOTRCH 
CONTROL SECTION 


5 890 


ERRTRA 
LCCATICN 


5898 
REFERS 


TO SYMBOL IN 










LOCATION 


CONTROL SECTION 




150 




SQRT 


IHOSSQRT 




154 




IBCCM# 


IHCECCMH 




360 




SEQDASD 


IH0CCMH2 




3B8 




IHCCCMH2 


IHCC0MH2 




F34 




ADCON# 


IHOFCVTH 




F2C 




FIOCS# 


IHCEFICS 




F38 




ARITH# 


IHOEFNTH 




F54 




ADJShTCH 


IHCEFNTH 




FC8 




IHOUOPT 


IHOUCPT 




F3C 




FCVECUTP 


IHCFCVTH 




F4C 




FCVLOUTP 


IHOFCVTH 




F44 




FCVIOUTP 


IHCFCVTH 




F48 




FCVCGUTP 


IHCFCVTH 




F4C 




FCVAOUTP 


IHOFCVTH 




F50 




FCVZCUTP 


IHCFCVTH 




102C 




IHOASYNC 


*UNRESCLVED(W) 




E8C 




IHCERRM 


IHOERRM 




EEC 




IHOERRE 


IHCERRM 


' 


F10 




IHCCGMH2 


IHCCCMH2 




EE4 




IH0CCMH2 


IH0CCMH2 


EE8 




IH0C0MH2 


IH0CCMH2 




EEC 




IH0CCMH2 


IH0CCMH2 


EFO 




IHCC0MH2 


IH0CCMH2 




117C 




IHOECOMH 


IHCECCMH 


1220 




IHCECOMH 


IHOECCMH 




1815 




IHOECOMH 


IHOECOMH 


1825 




IHCECOMH 


IHCECCMH 




1835 




IHCECCMH 


IHOECCMH 


g^ 1A9C 




IBCCM* 


IHOECCMH 




1AC4 




IHOERRM 


IHCERRM 


\P 2318 




IBCOM# 


IHCECCMH 




2314 




IHOERRM 


IHOERRM 


2368 




FQCONO# 


IHOFCONO 




236C 




FQCCNI# 


IHCFCCNI 


2AE4 




IBCOM# 


IHCECOMH 




2AE8 




INTShTCH 


IHCECCMH 


2A84 




INT6SWCH 


IHCFCVTH 




2A80 




IHOUOPT 


IHCUCPT 


2AF0 




ACCON# 


IHOFCVTH 




2AEC 




FICCS# 


IHCEFICS 


2BF0 




IHOERRM 


IHCERRM 




2E58 




IHOASYNC 


$UNRESCLVED(W) 


2E50 




IHOERRM 


IHCERRM 




2E54 




IH0FI0S2 


IH0FI0S2 




3B7C 




IHOUATBL 


IHOUATBL 




3B7C 




IBCOMO 


IHCECCMH 




3B91 




IH0FI0S2 


IH0FICS2 




3BA8 




IH0FI0S2 


IH0FICS2 




3DD9 




IH0FI0S2 


IHGFI0S2 




493C 




IHCCCCM 


$UNRESCLVED(W) 




493 8 




FQTEN# 


$UNRES0LVED(W) 




4934 




FTEN# 


IHCFTEN 




4DA4 




FTEN# 


IHOFTEN 




4DAC 




IHOQCONO 


$LNRESOLVED(W) 




4DA8 




FQTEN# 


SUNRESOLVED(W) 




54DC 




IHCUCPT 


IHCUCPT 




54E0 




IBCOM# 


IHCECCMH 




54E4 




IHOTRCH 


IHCETRCH 




54E8 




FIOCSBEP 


IHOEFIOS 




5A2C 




LDFIC# 


$UNRESCLVED(W) 




5A18 




IBCCM# 


IHOECCMH 




5A1C 




ADCCN# 


IHCFCVTH 




5A24 




FIOCSBEP 


IHOEFICS 














ENTRY ADDRESS 


00 
















TOTAL LENGT 


H 

DOES 


5B38 

NOT EXIST BUT 


HAS BEEN ADDED TC 


DATA SET 










1- 


„****MAIN 





Figure II- 8. Linkage Editor Output From Procedure-Specified Options 



Linkage Editor and Loader Output 109 



LOADER OUTPUT 



For the FORTRAN program illustrated in 
Figure I 1-2, loader output is shown in 
Figure I I- 9. Options current at the time 
of job submission are always listed (Figure 
II-9, A) followed by any printed output. 

MAP causes a load module map to be 
produced (Figure II-9, B) . The map 
produced by the loader is somewhat 
different from that produced by the linkage 
editor. Like the link edit map, the loader 
map shows the name and the location of each 
program unit' s beginning point. Unlike the 
link edit map, this map shows the absolute 
address rather than a relative address. 
The loader map also has a different format; 
it is designed horizontally, i.e., it is 
meant to be read across from line to line 
rather than down by column. 

Each control section is mapped with 
three entries: its name, its type, and its 
beginning address. In Figure II-9, MAIN is 



identified as a type SD program (Section 
Definition, signifying a control section) , 
and begins at absolute address 90008. 
IHOECOMH is also a type SD program and 
begins at absolute address 902C8; it 
contains IBCOM, FDIOCS, and INTSWTCH, all 
identified as type LR (Label Reference, 
signifying entry points within a control 
section). Sections called by the loader 
are identified by the character * after the 
section name. 

PRINT produces a message indicating the 
length of the program and its absolute 
entry point (Figure II-9, C) . 

The other loader options do not produce 
any printed output. LET marks the load 
module executable even though certain error 
conditions may have been detected. CALL 
permits the loader to search system 
libraries to resolve external references. 
RES permits the loader to search the MVT 
link pack area queue to resolve external 
references. SIZE indicates the amount of 
storage allocated to the loader step. 



-OPTIONS USED - PRINT, MAP, LET, CALL, RES, SIZE=65536 



CS/36C LCADER 



NAME TYPE ADDR 



NAME TYPE ADDR 



NAME TYPE ADDR 



NAME TYPE ADDR 



NAME TYPE ADDR 



© 



e { 



MAIN SD 


82808 


IHOECOMH* 


SD 


82AC8 


IBC0M# * 


LR 


82AF4 


FDICCS# * 


LR 


82BBC 


INTSWTCH* 


LR 


83878 


IH0C0MH2* SD 


8389C 


SEQDASD * 


LR 


83BFA 


IH0SSQRT* 


SD 


842C8 


IH$SQRT * 


LR 


84208 


SQRT * 


LR 


842C8 


IHOERRM * SD 


8437C 


ERRMON * 


LR 


84370 


IHOERRE * 


LR 


84388 


IH0U0PT * 


SD 


8496C 


IH0EFNTH* 


SD 


84C78 


ARITH# * LR 


84C78 


ADJSWTCH* 


LR 


851D8 


IHOEFIOS* 


SD 


8544C 


FI0CS# * 


LR 


85440 


FI0CSBEP* 


LR 


85446 


IHOFI0S2* SD 


8653C 


IHOFCVTH* 


SD 


86AE0 


ADC0N# * 


LR 


86AE0 


FCVAOUTP* 


LR 


86B8A 


FCVLOUTP* 


LR 


86C1A 


FCVZOUTP* LR 


86D76 


FCVIOUTP* 


LR 


8711A 


FCVCOUTP* 


LR 


872CC 


FCVEOUTP* 


LR 


872CC 


INT6SWCH* 


LR 


87468 


IH0FC0NI* SD 


874E8 


FOCCNI* * 


LR 


874E8 


IH0FC0N0* 


SD 


877E8 


FQCCN0# * 


LR 


877E8 


IH0UATBL* 


SD 


87D4C 


IHOETRCH* SD 


87F48 


IHOTRCH * 


LR 


87F48 


ERRTRA * 


LR 


87F50 


IHOFTEN * 


SD 


881FC 


FTEN# * 


LR 


881FC 


TOTAL LENGTH 


5B8C 


























FNTRY ADDRESS 


828C8 



























Figure I I- 9. Loader Output 



110 



LOAD MODULE OUTPUT 



Load module output consists of messages and 
program output. 



then called its subroutine FIOCS in which 
the error occurred. ) 



MESSAGES 



Load module messages are generated in three 
forms: error code diagnostics, program 
interrupt messages, and operator messages. 
Error code diagnostics indicate 
input/output errors or misuse of FORTRAN 
library functions. Program interrupt 
messages indicate violations of system 
restrictions. Operator messages indicate 
interrupts caused by execution of STOP n or 
PAUSE s ta teme nt s . 



ERROR CODE DIAGNOSTIC MESSAGES 



An error code diagnostic generates a 
message followed by a traceback map written 
in the error message data set (usually 
FT06F001). The traceback map provides a 
guide to the programmer in determining the 
cause of the error and shows the path of 
calls made between routines in the program. 

Figure 11-10 shows an example of an 
error code message and its related 
traceback map, generated for the FORTRAN 
program illustrated in Figure II-2. The 
message, IH0219I, indicates that a call was 
made to the FIOCS routine, which processes 
input/output requests for a FORTRAN 
sequential data set, and that the operation 
could not be completed because of a missing 
DD statement. The traceback map lists the 
names of called routines, internal sequence 
numbers within routines, and contents of 
registers, as follows: 

ROUTINE lists the names of all routines 
entered during processing. Names are shown 
with the latest routine called at the top 
and the earliest routine called at the 
bottom of the listing except when the 
earliest name shown is IBCOM. Then, the 
error could have occurred in one of the 
subroutines called by IBCOM. In this 
example, IBCOM, the FORTRAN input/output 
subroutine, was the last routine entered, 
called by MAIN, the main program. (IBCOM 



The entry CALLED FROM ISN lists the 
FORTRAN program's internal sequence number 
(ISN) that called the routine, except when 
calls were to IBCOM. ISNs are available to 
the traceback routine only if the compiler 
option GOSTMT was specified. 

The entry REG. 14 lists the absolute 
storage location of the instruction calling 
ROUTINE. 

The entry REG. 15 lists the absolute 
location of ROUTINE'S entry point. 

The entry REG. lists the results of 
function subprogram operations, when 
applicable. (In this example, the contents 
of register are meaningless. ) 

The entry REG. 1 lists the address of 
any argument list passed to ROUTINE. 

The message ENTRY POINT=010 87730 shows 
the entry point of the earliest routine 
entered. In the example, the number is 
identical to the number shown in register 
15 for MAIN. The numbers do not 
necessarily have to agree; for example, if 
MAIN had several entry points, the number 
in the ENTRY POINT message might show a 
different entry point. 

In Figure 11-10, the control program 
executed its own routine to recover from 
the error, and displays the following 
message: 

STANDARD FIXUP TAKEN, EXECUTION CONTINUING 

If the data processing installation uses 
its own error recovery routine, the word 
USER would replace STANDARD. 

After the fixup, execution continues. 
In the example, additional instructions 
calling for data set FT03F001 eventually 
cause execution to terminate. Message 
IHO900I explains that the number of errors 
exceeded the number permitted by the 
control program. A summary of errors is 
printed at the end of the listing to assist 
the programmer in determining how many 
times an error was encountered. 



Load Module Output 111 



FALLOWING IS A LIST OF PRIME NUMBERS FROM 1 TO 1000 
1 
2 
3 

IH0219I f=IOCS - MISSING DD CARD OR DCB ERROR FOR ASCII TAPE FOR FT03F001 



REG. 15 REG. REG. 1 
0004576C 00000005 FFFFFFFE 
01045480 FFFFFF2E 0005D7F8 



TRACEBACK ROUTINE CALLED FROM ISN REG. 14 
IBCOM 000456B0 

MAIM 0000F98C 

ENTRY POIMT= 01045480 

STANDARD FIXUP TAKEN , EXECUTION CONTINUING 

H0219I FIOCS - MISSING DO CARD OR DCB ERROR FOR ASCII TAPE FOR FT03F001 
TRACEBACK ROUTINE CALLED FROM ISN REG. 14 REG. 15 REG. REG. 1 
IBCOM 000456B0 0004576C 00000005 FFFFFFFF 

MAIN 0000F98C 01045480 FFFFFF2E 0005D7F8 

ENTRY POINT= 01045480 

STANDARD FIXUP TAKEN , EXECUTION CONTINUING 
H0219I FIOCS - MISSING DD CARD OR DCB ERROR FOR ASCII TAPE FOR FT03F001 



REG. 15 REG. 
0004576C 00000005 
01045480 FFFFFF2E 



REG. 1 
FFFFFFFE 
0005D7F8 



TRACEBACK ROUTINE CALLED FROM ISN REG. 14 
IBCOM 000456B0 

MAIN 000CF98C 

ENTRY POINT= 01045480 

STANDARD FIXUP TAKEN , EXECUTION CONTINUING 

H0900I EXECUTION TERMINATING DUE TO ERROR COUNT FOR ERROR NUMBER 219 
H0219I FIOCS - MISSING DD CARD OR DCB ERROR FOR ASCII TAPE FOR FT03F001 
TRACEBACK ROUTINE CALLED FROM ISN REG. 14 REG. 15 REG. REG. 1 
IBCOM 000456B0 0004576C 00000007 FFFFFFFE 

MAIN 0000F98C 01045480 FFFFFF2E 0005D7F8 

ENTRY POINT= 01045480 



SUMMARY OF ERRORS FOR THIS JOB ERROR NUMBER NUMBER OF ERRORS 

219 10 



Figure 11-10. Load Module Output with Traceback Map 



Using the Traceback Map 



In Figure 11-10, the messages generated 
during traceback processing indicate that: 

1. The error results from a missing DD 
statement for FT03F001; hence, an 
input/output operation is involved in 
the error, and, therefore, a FORTRAN 
input/output statement is involved. 



2. The FORTRAN statement is encountered 
many times rather than once, since 
multiple occurrences of the same 
traceback map result. 

From the foregoing description, the 
programmer can locate and correct either 
the DD statement or the FORTRAN statement 
containing 3 as its data set reference 
number. For the small program illustrated, 
the error may be easily located; if, 



112 



however, the source program is long and 
contains many input/output statements, the 
task of locating the error may be 
formidable. The traceback map further 
simplifies error location by pinpointing 
the exact FORTRAN statement involved. 

If the GOSTMT compiler option is 
specified, the traceback map lists the 
internal sequence number (ISN) calling each 
routine. From the ISN the source module 
statement can be located. The example 
illustrated in Figure 11-10 cannot take 
advantage of the GOSTMT option, however, 
because calls to IBCOM do not generate 
ISNs. 

In addition, the programmer can take 
advantage of the LIST compiler option. If 
the option is specified, an assembler 
language translation of the source module 
is printed. The traceback map, used in the 
following manner, locates the last 
assembler language instruction executed: 

1. For the topmost routine listed under 
the heading REG. 14, subtract the 6 
low-order digits in the number shown 
under ENTRY POINT. This produces the 
relative location of the instruction 
in the listing. In Figure 11-10, 
location 087730 subtracted from 087960 
yields 230. 



2. 



Find the location in the 
pseudo-assembler listing. A portion 
of the pseudo-assembler listing 
illustrated in Figure II-5 has been 
reproduced in Figure 11-11. Location 
230 contains a BAL (Branch and Link) 
instruction; this is the instruction 
that would have been executed next if 



one CliUl 



liCtVA UUl. Ul^^ULiCUl 



3. Using the location as a beginning 
point, scan upward in the column that 
identifies statement numbers to locate 
the nearest number occurring before 
the instruction; this will be the 
statement number of the FORTRAN 
statement involved in the error. In 
Figure 11-11, the statement number is 
107. 

4. Investigate the statement in the 
source module deck. Figure 11-12 
illustrates statement number 107 as it 
was coded and as it was keypunched. 
The statement had a keypunch error, 
designating 3 in place of 6 as the 
data set reference number. 

5. If the statement had been correctly 
specified, the programmer would 
investigate the corresponding DD 
statement for accuracy. (In this 
example, this step is, of course, 
unnecessary since the programmer 



intended no DD statement named 
FT03F001. ) 



PROGRAM INTERRUPT MESSAGES 



Program interrupt messages provide a guide 
to the programmer in determining the cause 
of the error; it indicates what system 
restriction was violated. Program 
interrupt messages are written in the 
object error message data set (usually on 
FT06F001). 

Figure 11-13 shows the format of a 
program interrupt message with and without 
the extended error handling facility. The 
extended error handling facility is 
discussed in detail in Part III in this 
publication. 

The meaning of characters enclosed in 
braces is as follows: 

A or Alignment 

indicates that the boundary alignment 
routine has been executed. Boundary 
alignment is performed to properly 
align items in storage. It is 
generally employed to ensure correct 
alignment of variables in a COMMON 
block or EQUIVALENCE group. Boundary 
alignment is performed if the option 
BOUNDRY=ALIGN is included at program 
installation time; otherwise, boundary 
violations cause the job to terminate. 
When boundary alignment is performed, 
message IHO210I is generated, for a 
maximum of ten performances. After 
ten performances, the message is 
suppresses uut axignment vioxations 
continue to be corrected. 



indicates that the interruption was 
precise, i.e., the PSW (program status 
word) shown in message IHO210I is the 
one related to the interruption. In 
some computer models, such as the IBM 
System/360 Model 91, instructions may 
be executed in a non-sequential order 
such that if an interruption occurs, 
the printed PSW may not be the one 
causing the interruption. Such 
interruptions are called imprecise 
interruptions. 

O or operation 

indicates that extended precision 
simulation has taken place. The 
simulator is a routine that forms part 
of the supervisor. Some models of the 
System/360 are equipped with hardware 
to accomplish arithmetic operations 
involving extended precision add, 
subtract, and multiply floating-point 



Load Module Output 113 



0C01F8 


5B 


10 


084 


0001FC 


58 


50 


OBC 


000200 


07 


95 




000202 


58 


50 


D OCO 


0C0206 


07 


25 




000208 


58 


00 


D 08C 


00020C 


5A 


00 


D 070 


000210 


50 


00 


D 08C 


000214 


59 


00 


D 088 


000218 


58 


50 


OBO 


0C021C 


07 


D5 




00021E 


58 


FO 


D 09C 


000222 


18 


00 




000224 


45 


EO 


F 004 


000228 


00000003 


0C022C 


0C000072 


000230 


45 


EO 


F 008 


000234 


04500084 


000238 


45 


EO 


F 010 


00023C 


58 


00 


084 


C00240 


5A 


00 


D 070 


000244 


50 


00 


D 084 


000248 


58 


00 


D 07C 


00024C 


5B 


00 


D 084 


000250 


58 


50 


D 0C4 


000254 


07 


45 




000256 


58 


50 


D OCO 


00025A 


07 


95 




0002 5C 


58 


50 


D OAC 


OOC260 


07 


25 




000262 


58 


FO 


09C 


000266 


18 


00 




000268 


45 


EC 


F 004 


00026C 


00000006 


000270 


00000076 


000274 


45 


EO 


F 010 


00C278 


58 


FC 


D 09C 


C0027C 


45 


EO 


F 004 



107 



108 



s 


1. 


132( 


0,13) 


L 


5, 


188( 


0,13) 


BCR 


9, 


5 




L 


5, 


192( 


0,13) 


BCR 


2, 


5 




L 


0. 


140( 


0,13) 


A 


0, 


112( 


0,13) 


ST 


0, 


140 ( 


0,13) 


C 


Ot 


136( 


0,13) 


L 


5, 


176( 


0,13) 


BCR 


13i 


5 




L 


15, 


156( 


0,13) 


LR 


0, 







BAL 


14, 


4( 


0,15) 


DC 


XL4 


•000C0C03' 


DC 


XL4 


■00000072' 


BAL 


14, 


8( 


0,15) 


DC 


XL4 


'0450 DO 84' 


BAL 


14, 


16( 


0,15) 


L 


0, 


132( 


0,13) 


A 


0, 


112( 


0,13) 


ST 


0, 


132( 


0,13) 


L 


0, 


124( 


0,13) 


S 


0, 


132( 


0,13) 


L 


5, 


196( 


0,13) 


BCR 


4, 


5 




L 


5, 


192( 


0,13) 


BCR 


9, 


5 




L 


5, 


172( 


0,13) 


BCR 


2, 


5 




L 


15, 


156( 


0,13) 


LR 


0, 


C 




BAL 


14, 


4( 


0,15) 


DC 


XL4 


•00000006' 


DC 


XL4 


00000076' 


BAL 


14, 


16( 


0,15) 


L 


15, 


156( 


0,13) 


BAL 


14, 


4( 


0,15) 



K 
2 
K 
J 
105 



IBCOM# 



I 

I 
2 
I 
1000 
I 
7 

4 

3 

IBCOM# 



IBCOM# 



Figure 11-11. Partial Object Code Listing 



instructions. On those models which 
are not thus equipped, the simulator 
performs these operations. The 
simulator is always required for 
extended precision divide 
instructions . 



Statement 107 as coded: 
107 WRITE (6,5)1 

Statement 107 as keypunched: 
107 WRITE <3, 5)1 



Figure 11-12. Comparison of FORTRAN 

Statement as Coded and as 
Keypunched 



Exception codes themselves appear in the 
eighth position of the PSW and indicate the 
reason for the interruption. Their 
meanings are as follows: 

Code Meaning 
1 indicates an operation exception , 

i.e., the operation was not one that 
could be defined by the operating 
system. 

4 indicates a protection exception , 

i.e., an illegal reference was made to 
an area of storage protected by a key. 



indicates an addressing exc ept ion, 
i.e., a reference was made to a 
storage location outside the range of 
storage available to the job. 



indicates a specification exception , 
i.e., a unit of information does not 
begin on its proper boundary. 



114 



Code Meaning 
7 indicates a data exception , i.e., the 
arithmetic sign or the digits in a 
number are incorrect for the operation 

9 indicates a fixed-point-divide 

exception , i.e., an attempt was made 
to divide by zero. 

C indicates an exponent -o ver f low 

exception , i.e., a floating-point 
arithmetic operation produced a 
positive number too large to be 
contained in a register (the largest 
number that may be contained is 16 63 
or approximately 7.2 x 10 75 ). 
Exponent-overflow generates the 
additional message: 

REGISTER CONTAINED number 

where: 

number is the floating-point number 
in hexadecimal format. (When 
extended- precision is in use, the 
message prints out the contents of 
two registers. ) If extended error 
handling is specified, a standard 
fixup is taken and execution 
continues; otherwise, job 
termination results. 

D indicates an exponent-underflow 
exception , i.e., a floating-point 
arithmetic operation generated a 
negative number too large to be 
contained in a register (larger than 
16-65 or approximately 5. 4 x 10- 79 ). 

Exponent- underflow also generates the 
message: 

REGISTER CONTAINED number 

(When extended-precision is in use, 
the message prints out the contents of 
two registers. ) If extended error 
handling is specified, a standard 
fixup is taken and execution 
continues; otherwise, job termination 
results. 

F indicates a floating-point-divide 

exception , i.e., an attempt was made 
to divide by zero in a floating-point 
operation. 

Floating-point divide also generates 
the message: 

REGISTER CONTAINED number 



(When extended-precision is in use, 
the message prints out the contents of 
two registers. ) If extended error 
handling is specified, a standard 



fixup is taken and execution 
continues; otherwise, job termination 
results. 

Note-; Operation, protection, addressing, 
and data exceptions (codes 1, 4, 5, and 7) 
ordinarily cause abnormal termination 
without any corresponding message. 
Protection and addressing exceptions (codes 
4 and 5) generate message IHO210I only if a 
specification exception (code 6) or an 
operation exception (code 1) has also been 
detected. A data exception (code 7) 
generates message IHO210I only if a 
specification exception has also been 
detected. When message IHO210I is 
generated for codes 4, 5, or 7, the job 
will terminate. The completion code in the 
dump indicates that job termination is due 
to a specification or operation exception; 
however, the error message indicates the 
true exception that caused the termination. 



Requesting a Du mp 



Under MFT and VS1, program interrupts 
causing abnormal termination produce a dump 
called an indicative dump which displays 
the completion code and the contents of 
registers and system control fields. 

To display the contents of main storage 
as well, the programmer must request an 
abnormal termination (ABEND) dump by 
including a SYS ABEND DD statement in the 
appropriate job step. The following 
example shows how the statement may be 
specified for IBM-supplied cataloged 
procedures • 

//GO. SYSABEND DD SYSOUT=A 

Information on interpreting indicative and 
ABEND dumps is found in the appropriate 
debugging guide, as listed in the Preface. 

To specify a dump under MVT and VS2, the 
programmer should include SYSUDUMP or 
SYSABEND DD statements. 



OPERATOR MESSAGES 



Operator messages are generated when a 
PAUSE or STOP n statement is executed. 
Operator messages are written on the system 
device specified for operator 
communication, usually the console. The 
message provides a guide to the programmer 
in determining how far his FORTRAN program 
has executed. 



Load Module Output 115 



1. Without Extended Error Handling Facility 

1^ 
4 
5 

A| )6| 

IHO210I PROGRAM INTERRUPT (^P/) OLD PSW IS xxxxxxx (7> xxxxxxxx 

O) J9| 

C 

D 

Fl 

2. With Extended Error Handling Facility: 

V 
4 
5 

(ALIGNMENT ) ) 6 1 

IHO210I IBCOM- PROGRAM INTERRUPT^ > OLD PSW IS xxxxxxx /7> xxxxxxxx 

(OPERATION) J 91 

D 

Fl 



Figure 11-13. Program Interrupt Message Format 



Figure 11-14 shows the form that the 
operator message may take. The meaning of 
lowercase characters in the figure is as 
follows: 



Character Meaning 

yy message identification number 
assigned by the system. 

n string of 1 through 5 decimal 
digits specified by the 
programmer in the statement. 
For the STOP statement, this 
number is placed in register 
15. 



PROGRAM OUTPUT 



Program structure dictates the form that 
program output will take. Generally, 
output that is to be used in future jobs is 
directed to tape or direct access volumes 
for storage; the programmer defines such 
volumes on appropriate DD statements. 
Output that is to be visible at job end is 
directed to a unit record device; when 
using cataloged procedures, the programmer 
may conveniently direct such output by 
assigning the appropriate data set 
reference number in his WRITE statements, 
or he may define his own DD statements. 



' message* literal constant specified by 
the programmer. 

printed when a PAUSE statement 

containing no characters is 
executed. (Nothing is printed 
for a similar STOP statement. ) 



A PAUSE message causes program execution 
to halt pending operator response. To 
resume program execution, the operator 
issues the command: 



Figure 11-15 shows the program output 
resulting from correct execution of the 
FORTRAN program illustrated in Figure II -1 
The first four lines are generated as a 
result of the WRITE statement labeled 100 
and the FORMAT statement labeled 8. All 
the remaining lines except the last result 
from WRITE statement 107 and FORMAT 
statement 5; the last line results from 
WRITE statement 7 and FORMAT statement 6. 

r 1 

Operator message caused by a PAUSE 
statement : 



REPLY yy, * z' 



where yy is the message identification 
number and z is any letter or number. 



n 



yy IHO001A PAUSE {'message' 





Operator message caused by a STOP n 
statement : 



A STOP message causes program 
termination. 



IHO002I STOP n 
Figure 11-14. Operator Message Format 



i j 



116 



FOLLOWING IS A 



PRIME NUMBERS FROM 1 TO 1COC 




r\ 




Figure 11-15. Program Output 



Load Module Output 117 



PART III — PROGRAMMIN G TECHNIQUES 



Load Module Output 119 



PROGRAMMING CONSIDERATIONS 



The programmer can significantly influence 
the efficiency of a job by the manner in 
which he uses FORTRAN statements and the 
facilities of the operating system. 

This chapter discusses the following: 

• FORTRAN implementation considerations 

• Job control language considerations 

• FORTRAN library considerations 

• System considerations 



FORTRAN IMPLEMENTATION 



This topic describes how the programmer can 
use FORTRAN statements and compiler 
facilities to implement an efficient 
program. Topics are arranged in alphabetic 
order. 



ARRAY CONSIDERATIONS 



Wherever possible, arrays should be 
specified as one-dimensional rather than as 
multi- dimensional. References to higher 
dimensioned arrays are slower than 
references to lower dimensioned arrays. 



ASYNCHRONOUS INPUT/ OUTPUT PROGRAMMING 
CONSIDERATIONS 

WAIT Statement : The WAIT statement need 
not appear in the same program unit as the 
corresponding READ or WRITE statement. 
However, the WAIT statement must identify 
the same list items as indicated in the 
list of the corresponding READ or WRITE 
statement. If OPTIMIZE (2) is requested, 
the WAIT statement list must be specified 
in order to ensure correct results. 

^WIND^_ENDFILE^_and^AC^PAC 
These statements should not be issued for 
any data set on which a request is 
outstanding, i.e., for any data set 
expecting a WAIT statement. 

'Jgb_Control Language, System^ and Library 

Considerations : The DD statement DCB 
parameter affects asynchronous input/output 
processing as follows: 

1. BLKSIZE specifies the block length. 
If it is not specified, for direct 
access devices the optimum block 
length for the particular device is 
assumed; for magnetic tape the block 
length defaults to 10K bytes. 

2. BUFNO specifies the number of buffers 
(1, 2 or 3). If it is not specified, 
two buffers are assumed. 

3. RECFM specifies the record format and 
may be specifed as either VS or VST. 
If RECFM is not specified, VS is 
assumed. 



ARITHMETIC IF STATEMENT 



A test depending on the zero value of a 
real floating-point number is not 
recommended. Many real numbers must be 
represented approximately (although to a 
high degree of accuracy) in the internal 
hexadecimal code of the computer. Slight 
errors resulting from computation with 
these numbers may prevent the anticipated 
true zero condition from being obtained. 



A fixed-point overflow condition in an 
arithmetic IF statement causes the middle 
branch (i.e., equal zero) to be taken. 



The following system restrictions affect 
asynchronous input/ output processing: 

1. If track overflow is specified 
(RECFM=VST), chained scheduling and 
backspacing are not permitted. 

2. The asynchronous input/output facility 
does not check the characteristics of 
the data it moves (e.g., whether 
padded, promoted, REAL+16, etc.). 
Specifying correct data types is the 
programmer's responsibility. 

3. A data set accessed by asynchronous 
input/output may not be accessed by 
any other type of input/output 
facility unless the data set is 
rewound before input/output facilities 
are changed. 



Programming Considerations 121 



4. Asynchronous input/output is not 

supported for unit record equipment, 
or for direct-access data sets. 



The following library considerations 
affect asynchronous input/output 
processing: 

1. Asynchronous input/output operations 
are assigned to a task having a higher 
priority than the main program, 
thereby permitting the operations to 
occur asynchronously with computation. 

2. Each logical record is assigned the 
format RECFM=VS. The programmer may 
specify track overflow by coding 
RECFM=VST but blocked records are not 
permitted. If blocked records are 
specified, the RECFM request is 
ignored and RECFM=VS is assigned. 



BACKSPACE STATEMENT 



The BACKSPACE statement may be used to 
extend a data set, i.e., write additional 
data. In a program containing DD 
statements with more than one FORTRAN 
sequence number, the execution of an 
ENDFILE followed by the execution of a 
BACKSPACE does not cause the sequence 
number to increment; the latest data set 
remains available. 



operations data may be stored in locations 
not necessarily contiguous; on output, data 
may be gathered from diverse storage 
locations. To make input/output operations 
more efficient, the following technique is 
suggested: 



An I/O list comprising many items in a 
READ or WRITE statement should be 
defined in a COMMON statement to 
allocate contiguous storage space. An 
EQUIVALENCE statement should be defined 
which contains one item, equal in size 
to all the items in the I/O list, thus 
permitting the same space to be referred 
to by one name. Finally, an 
input/output statement calling the one 
name permits all items to be treated as 
one unit. An example follows : 

COMMON/LI STA/ A ( 4 ) , B ( 4 ) , C, D, E, F, G ( 8 ) 
REAL+4 A(4),B(4),G(8) ,LISTB(20) 
EQUIVALENCE (A(l) , LISTB(l) ) 
WRITE(6) LISTB 

Note that the variable and the 
equivalenced array must be of the same 
type. 



COMMON STATEMENT 



The following restrictions govern the 
use of the BACKSPACE statement: 

1. It may not be used for any data set 
specifying track overflow (e.g., 
RECFM=FT). 

2. It should not be used for any data set 
executing list- directed input/output 
statements (e.g., WRITEdO, *) A) 
because it would cause uncertain 
record placement. 

3. When asynchronous input/output 
processing is specified, it should not 
be executed for any data set on which 
a request is outstanding, i.e., for 
any data set expecting a WAIT 
statement. 



Use of COMMON to contain variables passed 
among calling and called programs can 
result in time and storage savings. 
Consider the following example : 



DIMENSION E (20), I (15) 

READ (10) A, B,C 

CALL SUBA (A, B,C,D,E,F,I) 



END 



SUBROUTINE SUBA ( P, Q, R, S, T, U, J) 
DIMENSION T(20),J(15) 



COMMON AND EQUIVALENCE STATEMENTS USED 
TOGETHER 



Increased efficiency occurs when 
input/output operations are performed on 
data stored in contiguous storage 
locations. Normally, however, in input 



RETURN 

END 



The compiler must assign storage to both 
main program and subprogram variables and 
must issue instructions required to 
transfer the variables from one program to 
another. Greater efficiency would result 
by specifying a COMMON block as follows: 



122 



COMMON A,B,C,D,E(20),F,I(15) 
READ (10) A,B,C 
CALL SUBA 



END 

SUBROUTINE SUBA 

COMMON P,Q,R, S,T(20),U,J(15) 



RETURN 
END 



made may be partially or completely 
eliminated in a program compiled with 
OPTIMIZE (1) or OPTIMIZE (2) in which calls 
to user subprograms occur between two uses 
of a variable. If the variable is in 
COMMON, it will be stored before the call 
and must be loaded from storage after the 
call. If the variable is not in COMMON, it 
can be retained in a register and thus used 
more efficiently. This is true of 
relatively high-activity variables. 



DATA INITIALIZATION STATEMENT — SPECIFYING 
LITERALS 



To initialize an array with literal data, 
the programmer should consider the 
following points: 



2. He may initialize several consecutive 
elements of an array with a single 
constant by specifying the array name 
without a subscript. Spill occurs 
through as many elements as necessary 
to insert the constant (as long as the 
constant does not exceed the limits of 
the array). The following example 
illustrates how several array elements 
may be initialized with one constant: 

DIMENSION ARRAY(9> 

DATA ARRAY/' ABCDEFGHIJKLMNOPQRS 

TUVWXYZ* / 
ARRAY(1)=ABCD 
ARRAY(2)=EFGH 
ARRAY(3)=IJKL 
ARRAY'. 4) =MNOP 
ARRAY(5)=QRST 
ARRAY(6)=UVWX 
ARRAY(7)=YZbb 
ARRAY(8) and ARRAYO) not initialized. 



Note that spill normally begins only 
at the beginning of an array. To 
begin spill in the middle of an array, 
the programmer uses the EQUIVALENCE 
statement as in the following example : 

DIMENSION ARRAYA(IO) ,ARRAYB(5) 
EQUIVALENCE ( ARRAYA ( 6 ) , ARRAYB ( 1 ) ) 
DATA ARRAYB/ ' ABCDEFGHI JKLMNOPQRST' / 
ARRAYA(l) through ARRAYA(5) not 

initialized 
ARRAYA(6)=ABCD 
ARRAYA(7)=EFGH 
ARRAYA(8)=IJKL 
ARRAYA(9)=MNOP 
ARRAYA(10)=QRST 



1. He may initialize any element of an 
array by subscripting the array name. 
Only one element is initialized; if 
excess characters are specified, they 
are not placed, or spilled, into the 
next element. (Overflow from one 
element to the next is known as 
spill . ) An array element partially 
filled is padded on the right with 
blanks. The following example 
illustrates how individual array 
elements may be initialized: 

DIMENSION A (10) 

DATA Ml), A(2),Mfn,M5)/'ABCD*, 

• QRSTUVW ,'123' , 6666,/ 

A(1)=ABCD 

A(2)=QRST 

A(3) not initialized (note that spill 
does not occur for a subscripted 
array name) 

A(4)=123 

A(5)=6666 

A(6) through A(10) not initialized. 



3. He may initialize individual variables 
after initializing an array. Each 
constant must be specified immediately 
following the variable which it is to 
initialize. The following example 
illustrates how literal data for 
arrays and variables may be specified 
together: 

DIMENSION ARAY(5) 

DATA ARAY/' ABCDEFGH* /, X/' 4444* / 

, Y/'5555V 
ARAY(1)=ABCD 
ARAY(2)=EFGH 
ARAY(3) ,ARAY(4> , and ARAY(5) not 

initialized 
X=4444 
Y=5555 



If each constant is not specified 
immediately after its associated array 
or variable name, spilled data may be 



Programming Considerations 123 



overlaid, as shown in the following 
example: 

DIMENSION A(3) 

DATA A, X/' ABCDEFGHIJKL' ,10.0/ 

A(1)=ABCD 

A(2)=10.0 

A(3)=IJKL 

X is not initialized 

In this example, the second element of the 
array is overlaid by the second 
initializing constant. 



DIRECT-ACCESS INPUT/OUTPUT CONSIDERATIONS 



Direct-access input/output provides the 
programmer with the ability to retrieve 
selected records from a data set, i.e., 
records can be retrieved without the 
necessity of reading all preceding records. 

Direct-access input/output is suited to 
applications where large tables must be 
freguently searched during processing or 
where data sets are constantly updated. 

Master and Detai] Records : Records to be 
updated are called master records . Records 
containing information used to update 
master records are called detai l records. 
In a direct-access data set, each master 
record should be constructed such that it 
contains a unique identification, or key, 
distinguishing it from all other master 
records. Each detail record should match 
the key of the appropriate master record. 
For example, astronomers assign numbers to 
identify stars; these star numbers could be 
used as the keys of master records, and 
detail records update the correct master 
record by matching the star number. Thus, 
detail records to update information for 
star number 383320 should contain a field 
specifying 383320 as the key of the master 
record. 

A FORTRAN program indicates the record 
to be processed by its position in the data 
set. If star number 383320 is assigned to 
record position 383320 in the data set, the 
key can also be used to indicate the record 
position. Sometimes, however, arranging 
records in serial order is impractical (a 
data set might not contain 383320 
positions). In such cases, the programmer 
can more conveniently arrange records in 
the data set by using a randomizin g 
tech nique . For example, a randomizing 
technique to arrange star numbers might be 
to use the first four digits as the record 
position and to ignore the last two digits. 
Thus, star number 383320 is assigned to 
position 3833. 



Another method might be to perform an 
algorithm on the number, such as squaring 
the number and truncating the first four 
and last four digits of the result. In 
this example, star number 383320 is 
assigned record position 3422. No general 
randomizing technique works best for all 
sets of identification numbers; the 
programmer should devise his own technique 
for each application. 

S ynonyms : Two problems arise when 
randomizing techniques are used: waste of 
space in a data set and duplication of 
record position numbers, called synonyms 
(e.g., by ignoring the last two digits, 
star numbers 383320, 383352, and 383396 
randomize to the same number, 3833). The 
solution to the first problem should be 
developed within the randomizing technique 
itself. For example, if no star number 
begins with zero, the first thousand record 
positions are left blank (star number 
123456 would be assigned to record position 
1234). To eliminate this waste, a step 
might be added to this randomizing 
technique to subtract 1000 from the 
randomized numbers (star number 123456 
would then be assigned to position 0234). 

Chaining: The solution to the second 
problem is either to develop another 
randomizing technique that results in fewer 
synonyms, or to chain synonyms. Chaining 
is a method of arranging non-contiguous 
records in a chain such that each record 
contains a field specifying the location of 
the next record in the chain; the last 
record in the chain may contain in the 
field to indicate the end of the chain. 
For example, see Figure III-l which 
illustrates how star numbers 383320, 
383396, and 383352, randomized to 3833, 
might be chained together. 

Since only one record can be assigned to 
any one record position (if star number 
383320 is assigned to record position 38 33, 
star numbers 383396 and 383352 must be 
assigned elsewhere), space to accommodate 
synonyms must be allocated to a data set. 
For example, if no star number begins with 
zero, the programmer may choose to keep the 
first thousand positions of the data set 
available for synonyms. Thus, star numbers 
383396 and 383352 are assigned somewhere in 
the first thousand record positions. To 
keep track of the exact location of any 
synonym, the programmer should create a 
record location counter (a dummy record 
that is initialized to the lowest record 
position available for synonyms, e.g., 
record position 1 in the example above). 
When the first synonym is encountered, it 
is inserted into record 1; address 1 is 
stored in the chaining field of the 
previous record having the same 
identification; and the location counter is 



124 



incremented by 1. The next synonym is 
allocated to the next record and the 
address of that record is stored in the 
chaining field of the previous record. The 
same procedure is followed for each 
succeeding synonym. 



Cre ating a Direct-Access Data Set : To 
create a direct-access data set, the 
programmer initializes the volume by 
writing "skeleton records" using an 
installation-written routine. After the 
data set has been initialized, the 
programmer specifies DISP=OLD in the DD 
statement that defines the data set, and a 
FORTRAN load module can enter records into 
it. However, if a data set cannot be 
initialized prior to execution time, the 
programmer can initialize it at execution 
time by specifying DISP=NEW; the FORTRAN 
load module writes skeleton records into 
the volume as a series of blanks 
(hexadecimal 40). 



Figure III-2 shows a block diagram 
describing the logic that can be used to 
write a direct-access data set for the 
first time. The block diagram does not 
show any attempt to write skeleton records. 



For an example showing how a 
direct-access data set can be updated, see 
the section "Appendix A: Examples of Job 
Processing. " 



DEFINE FILE STATEMENT: 



The record 



description information in a DEFINE FILE 
statement must be consistent with space 
allocation specified in the SPACE parameter 
of the DD statement. The example below 
illustrates this relationship. 

DEFINE FILE 8 (1000, 40, E, I) 



Identifier Chain 



r t t- 

| | Record | 
(383320 j Position forj 
| | 383396 | 

L ± , X. 



Data 



r t t- 

| | Record | 
1383396 | Position f or | 
| | 383352 | 

L L „ L. 



Data 



383352 



End 
of 
Chain 



Data 



//DD1 



DD 



SPACE=(40, (1000))... 



Figure III-l. Record Chaining 



FINDST ATEMENT : The FIND statement permits 
record retrieval to occur concurrently with 
computations of input/output operations, 
thus resulting in a decrease in execution 
time. The example below illustrates the 
use of the FIND statement. In this 
example, record 101 is retrieved while 
arithmetic operations are performed and is 
available for processing when the READ 
statement is reached. 

FIND (8*101) 
10 A=SQRT(X) 



E=ALPHA+ BETA* SIN ( Y ) 
WRITE (9)A,B,C,E 
READ (8'IODX, Y 



Both the DEFINE FILE statement and the 
SPACE parameter describe 1000 records, each 
40 bytes in length. 



EQUIVALENCE STATEMENT 



The DEFINE FILE statement may not be in 
a program unit that is overlaid; it may, 
however, be in a program unit not overlaid 
while the corresponding input/output 
operations are specified in an overlaid 
program unit. For example, the main 
program may specify the DEFINE FILE 
statement and a subprogram may perform 
input/output operations. 



To reduce compilation time for 
eguivalence groups, the entries in the 
EQUIVALENCE statement should be specified 
in descending order according to 
displacement. Consider the following 
example: 

EQUIVALENCE (VARA, ARAYA ( 3 ) , ARAYB ( 5 ) , 
ARAYC(IO) ) 



Programming Considerations 125 



Write Record 

Containing 

Record 

Location 

Counter 



(^ St °P ) 



Set Record Position 
in Read Statement 
= Chain Variable 



DEFINE FILE 

Allowing enough 

Space for Synonyms 



I 



Set Record 
Location Counter 
Lower Limit of 
Space for Synonyms 




Identification 

Number to 

Record Location 




Write 
Master 
Record 



Build 
Master 
Record 



Set Chain 

Variable in Master 

Record = Record 

Location Counter 



Write 

Master 

Record 



Set Record Position 
in Write Statement 

= Record 
Location Counter 



Increment 

Record Location 

Counter by 1 



Figure III-2. 



Writing a Direct-Access Data 
Set for the First Time 



This statement would be compiled faster by 
reversing the order, i.e., 

EQUIVALENCE ( ARAYC < 10 ) , ARAYB ( 5 ) , ARAYA< 3 ) 
VARA) 

To reduce compilation time and save 
internal table space, equivalence groups 
should be combined where possible. 
Consider the example: 

EQUIVALENCE (ARRAdO, 10) , VARl) , 
(ARRB(5, 5) VARl) 

This statement could be recoded more 
efficiently as: 

EQUIVALENCE (ARRAdO, 10) , ARRB(5, 5), VARl) 



EXTERNAL STATEMENT 



By placing an ampersand before a function 
name in an EXTERNAL statement, the 
programmer "detaches" that name, i.e., 
declares it to be the name of a 
user-supplied function even though the name 
may be the same as a function or subroutine 
appearing in the FORTRAN library. If the 
function name following the ampersand is 
not the same as a library function, it is 
still considered detached; no diagnostic 
action is taken. 

Also, by specifically typing a 
subprogram name, the programmer detaches 
the name from the library; for example, if 
SIN is typed as REAL* 8, it is detached from 
the FORTRAN library. 



GENERIC STATEMENT 



The GENERIC statement requests the use of 
the Automatic Function Selection facility; 
i.e., the appearance of the generic name in 
a program causes the appropriate function 
name to be substituted according to the 
length and type of the arguments specified. 
For example, the generic name COS, 
specified with arguments of REAL+8, causes 
the function DCOS to be substituted. 

In order to avoid conflict with specific 
references to functions, the function names 
substituted as a result of automatic 
function selection are aliases, not 
otherwise obtainable by the user. The 
aliases are formed by prefixing the 
characters IHO$$ to function names three 
characters in length, and IH$ to names four 
to six characters in length. Names six 
characters in length are reduced to five 
characters by deleting the next to last 



126 



character before prefixing the name with 
IH$. For example, the function DCOTAN 
substituted for COTAN would appear to have 
the name IH$DCOTN. 



INPUT/ OUTPUT STATEMENTS — UNFORMATTED 
FORMS 



The unformatted form of an input/output 
statement results in a faster data transfer 
rate into and out of storage. When 
operations are being performed on 
intermediate data sets, (those which are 
not intended to be printed), use of the 
unformatted forms increase program 
efficiency. In the example below, 
statement 11 is more efficient than 
statement 10: 

DIMENSION A(10),B(10),D(20> 
EQUIVALENCE (A(1),D(D) 

10 WRITE (20, 9) A, B 

9 FORMAT (10E13.3/) 

11 WRITE (20) D 



In statement 7, the compiler analyzes each 
set of comparisons separately; that is, the 
statement is compiled as though it were 
written: 

IF (A.LT.B) GO TO 15 
IF (C.EQ.D) GO TO 15 



Thus, at execution time, if the first test 
is true, the remainder of the expression is 
not evaluated. Statement 8, however, must 
be evaluated in its entirety before a 
branch decision can be made. 

The programmer can further improve the 
execution time of a logical IF statement by 
specifying as the first test the comparison 
that is most likely to be true. For 
example, in statement 7 above, if the test 
C.EQ.D is expected to be true more often 
than the test A.LT.B, the programmer should 
write the statement as follows: 

IF (C.EQ.D .OR. A. LT. B) GO TO 15 



Note : A, B, and D must be the same type. 

Unformatted input/output statements may 
not be used for ASCII data sets. 



LIST-DIRECTED INPUT/OUTPUT 



The buffer length (specified by BLKSIZE) 
must be large enough to contain the largest 
data item other than a complex item or 
literals in quotation marks; if it is not, 
an infinite loop results as the operating 
system attempts to get more space for the 
item. 



NAME HANDLING 



The compiler places names used for 
variables, arrays, and subprograms into a 
table and searches the table whenever a 
reference is made to a name. The table is 
divided into six strings. Names that are 
one character long are placed into the 
first string; names two characters long are 
placed into the second string; and so on. 
For faster compiling, the programmer should 
allocate names as evenly as possible among 
the sizes. 



OPTIMIZE COMPILER OPTION 



LOGICAL IF STATEMENT 



Use of the logical IF statement may result 
in more efficient compilation time. For 
example, statement 5 below is more 
efficient than statement 6 : 

5 IF (A. GT.B) GOTO 20 

6 IF (A-B) 10,10,20 
10 CONTINUE 

When a choice between logical operators 
can be made, the .OR. operator should be 
selected in place of the .AND. operator. 
For example, statement 7 below is more 
efficient than statement 8 : 

7 IF (A.LT.B .OR. C.EQ.D) GO TO 15 

8 IF (.NOT. (A.GE.B .AND. C.NE.D)) GO TO 15 



The OPTIMIZE option permits compiler 
optimization techniques to improve 
execution time and to reduce the size of 
the object module. 



OPTIMIZE(l) causes the entire program to 
be treated as a loop, with individual 
sections of coding, headed and terminated 
by labeled statements, treated as blocks. 
The object code is made more efficient by: 

• Improving local register assignment. 
(Variables that are defined and used in 
a block are retained where possible in 
registers during the processing of the 
block. Time is saved because the 
number of load and store instructions 
are reduced. ) 



Programming Considerations 127 



• Retaining the most active base 
addresses and variables in registers 
across the whole program. (Retention 
in registers saves time because the 
number of load instructions are 
reduced. ) 

• Improving branching by the use of 
assembler language RX format branch 
instructions in the object code. (An 
RX branch instruction saves a load 
instruction and reduces the number of 
reguired address constants. ) 

0PTIMIZE(2) performs object code 
optimization beyond that performed by 
OPTIMIZE (1) by: 

• Assigning registers across a loop to 
the most active variables, constants, 
and base addresses within the loop. 

• Moving outside the loop many 
computations which need not be within 
the loop. 

• Recognizing and replacing redundant 
computations . 

• Replacing where possible multiplication 
of induction variables by addition of 
those variables. (An induction 
variable is one that is only 
incremented by a constant or a variable 
whose value remains constant in the 
loop. ) 

• Using, where possible, the BXLE 
assembler instruction for loop 
termination. (The BXLE instruction is 
the fastest conditional branch; time 
and space are saved. ) 

Registers 0, 1, and 12-15 are required 
by the system. The remaining registers, 
2-11, are available for use by optimization 
techniques. 



PROGRAMMING CONSIDERATIONS WHEN USING 
OPTIMIZE(l) AND OPTIMIZED) : Although 
these options can result in more efficient 
code, they place additional 
responsibilities on the programmer in 
coding his program with care. 

Usin g COMMON State ments: Variables in 
COMMON are normally not stored on exit from 
a FORTRAN main program, unless an 
input/output statement or a subroutine call 
using them is issued. 

Usin g Subprograms : If a programmer-defined 
subprogram is given the same name as a 
FORTRAN- supplied subprogram (e.g., SIN, 
ATAN), errors could be introduced during 
optimization. To avoid errors, the 
programmer should specify the subprogram 



name in an EXTERNAL statement (with an 
ampersand preceding the subprogram name). 



If the extended error handling facility 
is specified and a user-supplied subroutine 
uses program variables, there is no 
guarantee that correct values will be 
available. 

If a subprogram is called at one entry 
point for the purpose of initializing 
arguments and at another entry point for 
computations, the latter call must include 
an argument list to ensure that the 
subprogram will receive current values for 
the arguments. This rule applies when the 
subprogram refers to the arguments by name 
(i.e., accesses them in their location in 
the calling routine rather than through 
local variables). 

In the following example, the updated 
value of I will be correctly stored and 
transmitted to the subprogram. If the call 
to the subprogram did not include the 
argument list, I would be updated in a 
register but not in storage. 

CALL INIT(I) 



10 CALL COMP(I) 
1=1+1 

GO TO 10 

SUBROUTINE I NIT (/J/) 

ENTRY COMP(/J/) 

Because each COMMON block is an 
independent program unit, it is 
independently relocatable and thus requires 
a base address that specifies its beginning 
point in storage. Each base address must 
be stored into a register in order to be 
accessible. If many COMMON blocks are 
defined, the need to load base addresses 
slows down processing time. If multiple 
blocks can be combined into one block less 
than 4096 bytes in length (the maximum 
number that can be accommodated in a 
register) one base register can serve to 
address each variable. 

Using the Assigned GO TO Statement : If the 
list of statement numbers is incomplete, 
errors that were not present in the 
unoptimized code may appear. The 
programmer should correct such GO TO 
statements. 



128 



PROG RAMMING CONSIDERATIONS WHEN USING 
OPTIMIZE (2) ; OPTIMIZE (2) evaluates 
expressions and eliminates common 
expressions. For example, if an expression 
occurs more tnan ones sucn tnat tns program 
path always passes through the first 
occurrence to reach a later occurrence with 
no change in the expression's value, the 
first value is saved and used instead. 
Consider the following example: 

A=C+D 



5 
100 



READ (4,100, ERR=200) A 
FORMAT (110) 



200 READ (4,100) AX 
GO TO 5 

If the ERR parameter is not provided, an 
input error causes the program to terminate 
processing, unless the extended error 
handling feature is in effect. For a 
discussion of this feature, see the chapter 
"Extended Error Handling Facility." 



F=C+D+E 

The common expression C+D is saved from its 
first evaluation occurring in A and is used 
in F. 

Computational Reordering : Computational 
reordering performed by OPTIMIZE (2) may 
produce unexpected results. For example, a 
test of an argument of a FORTRAN library 
function may be executed after the call to 
the function. This is caused by the 
movement of the function call to the back 
target of the loop when the function 
argument is not changed within the loop. 
Consider the following example: 

DO 11 1=1,10 

DO 12 J=l,10 
9 IF (B(I).LT.O) GO TO 11 
12 C(J)=SQRT(B(I) ) 
11 CONTINUE 

The optimization technique moves the 
library function call to before statement 
9, causing the square root computation to 
occur before the test for zero. To avoid 






~„,,n j y»~ 



tnis situation, tuc program cou±u u& 
reconstructed in the following manner: 

DO 11 1=1,10 
9 IF (B(I).LT.O) GO TO 11 

DO 12 J=l,10 
12 C(J)=SQRT(B(D) 
11 CONTINUE 



RETURN STATEMENT 



The RETURN statement issues the following 
codes in register 15: 



Code 




4*i 



16 



Meaning 

A RETURN statement was executed 

in either a main program or a 

subprogram 

A RETURN i statement was 
executed in a subprogram 

A terminal error was detected 
during execution of a library 
subprogram 



STOP STATEMENT 



In the STOP n statement, any number 
specified larger than 4095 causes an 
overflow into a system return code field; 
the return code that will be issued is n 
modulo 4096, that is, the remainder after 
dividing n by 4096. However, the number 
specified by the programmer will be 
displayed. 



USER- SUPPLIED SUBROUTINES 



READ STATEMENT 



The ERR parameter in the READ statement 
causes a branch to another statement if an 
input error is encountered. The READ 
statement encountering the error does not 
bring the data into working storage; the 
data remains in the buffer when the branch 
is taken. The next READ statement brings 
in the data. Thus, the programmer can 
direct the ERR parameter to an error 
processing routine that reads in the error 
and disposes of it prior to returning to 
normal processing. An example is: 



A user-supplied routine having the same 
name as a FORTRAN-supplied subroutine or 
function causes the linkage editor to issue 
the following warning message: 

IEW024I EXTERNAL SYMBOL PRINTED IS DOUBLY 
DEFINED ~ ESD TYPE DEFINITIONS 
CONFLICT. 



JOB CONTROL LANGUAGE CONSIDERATIONS 



The following list describes how DD 
statement parameters can improve efficiency 



Programming Considerations 129 



of a program (see the section "Using Job 
Control Language" for examples in coding DD 
statements) : 

• The SEP parameter may assign data sets 
whose input/output operations occur at 
the same time to separate channels. 

• The SEP subparameter in the UNIT 
parameter may assign data sets to 
separate direct access device arms. 
The SEP subparameter results in device 
optimization; the SEP parameter , 
described above, results in channel 
optimization. 

• The DISP parameter may specify the 
CATLG option for frequently used data 
sets to make use of the system' s 
cataloging capability. 

• Subparameters in the DCB parameter may 
be used as follows: 



a. 



b. 



c. 



BUFNO may be specified as BUFN0=2 
to provide double buffering, 
resulting in an input /output 
overlap advantage. 

BLKSIZE may be specified to provide 
a large buffer, resulting in fewer 
input/output requests. 

OPTCD=C may be specified to provide 
chained scheduling, which may 
result in decreased transfer time 
for input/output operations. 



parameter DSNAME=6ddname in a DD statement, 
replacing ddname with the name of a 
pre-allocated data set. (Pre- allocated 
data sets are defined in the cataloged 
procedures calling the MVT or VS2 
initiator. ) The programmer codes the other 
DD statement parameters that he normally 
would to define a new data set, i.e., UNIT, 
SPACE, DCB. An example is the following: 

//MYNAME DD DSNAME=6DED1, UN1T=SYSSQ, 

// SPACE=(80, (100,10)) , 

// DCB=(RECFM=F,BLKSIZE=80) 

The following restrictions apply when 
using pre-allocated data sets: 

• Data sets must be on direct access 
devices. 

• Space is provided only for the duration 
of the job; if the programmer wishes to 
keep a data set after job completion, 
he should not use pre-allocated data 
sets. 

• If the system cannot assign a 
pre-allocated data set, the 
programmer-coded DD statement is used 
to create a temporary data set. 

Detailed information on pre-allocated 
data sets may be found in the publication 
IBM System/360 Operating System: System 
Programmer ' s Guide , Order No. GC28-6550, 
OS/VS1 Planning and Use Guide , Order 
No. GC2U-5090, or OS/VS2 Planning Guide , 
Order No. GC28-0600, as appropriate. 



USING PRE-ALLOCATED DATA SETS 



Installations operating under MVT or VS2 
can provide pre-allocated data sets as an 
aid in reducing the time required by the 
system to allocate data sets used on a 
temporary basis. 

Whenever a data set is defined in a DD 
statement, the system must search for 
allocation space and must build storage 
tables to describe data set 
characteristics; the more data sets 
defined, the greater the time required to 
perform these operations. 

Pre-allocated data sets are allocated 
once, when the system is initiated and 
remain available for use by all jobs 
submitted to the system. Use of 
pre-allocated data sets avoids the 
necessity of having the system repeat the 
allocation process. 

If his installation provides 
pre-allocated data sets, the FORTRAN 
programmer can use them by coding the 



FORTRAN LIBRARY CONSIDERATIONS 



The uses of the utility subprograms DUMP 
and PDUMP, the sense light subprograms, and 
detaching library subprogram names, are 
discussed in the following paragraphs. 



DUMP AND PDUMP SUBPROGRAMS 



The DUMP and PDUMP subprograms write the 
contents of storage onto the system output 
data set; DUMP causes the program to 
terminate processing and PDUMP permits the 
program to continue processing. 

In using either subprogram, the user 
specifies the following: 

1. The variables delimiting the storage 
areas to be dumped. More than one 
area may be specified. 



130 



2. 



The format of the items to be dumped, 
coded as follows: 



EXTENDED- PRECISION SUBROUTINES 



Code 



Format 



f) 


Hexadecima 


1 


LOGICAL+1 


2 


LOGICAL* 4 


3 


INTEGER* 2 


4 


INTEGER+4 


5 


REAL* 4 


6 


REAL* 8 


# 


COMPLEX* 8 


8 


COMPLEX* 16 


9 


LITERAL 


10 


REAL* 16 


11 


COMPLEX* 3 2 



The extended-precision subroutines are 



The following examples illustrate how a 
user may specify storage areas to be 
dumped : 



\£±A f.-.y «.-.ca ukd 



required. Note, however, that each 
extended-precision subroutine increases the 
execution time of a program (approximately 
3 to 9 times longer than the corresponding 
double precision subroutine) . 



SENSE LIGHT SUBPROGRAMS 



If the programmer intends to use the SLITE, 
SLITET, DVCHK, or OVERFL subprograms, he 
should initialize the indicators to zero at 
the beginning of his program since the 
system does not automatically initialize 
them. 



1. To dump a single variable, the user 
specifies the variable name as both 
the beginning and the ending point. 
For example, to dump the variable B in 
real format and to terminate 
processing, the user specifies the 
statement: 



SYSTEM CONSIDERATIONS 



Compilation and load module considerations 
are discussed in the following paragraphs. 



CALL DUMP (B,B,5) 



2. To dump more than one variable 

individually, the user specifies each 
variable. For example, to dump 
variables A, B, and C in real format 
and to continue program processing, 
the user specifies: 



CALL PDUMP (A, A, 5, B, B, 5, C,C, 5) 



3. To dump all of main storage between 
variables, the user specifies the 
first and last variable to be dumped. 
For example, to dump main storage 
between variables A and C in real 
format and to continue program 
processing, the user specifies: 

CALL PDUMP (A, C, 5) 



4. To dump an array, the user specifies 
the first and last elements of the 
array. For example, to dump the array 
TABLE containing 20 elements in 
hexadecimal format and to terminate 
program execution, the user specifies: 

CALL DUMP ( TABLE ( 1 ), TABLE ( 20 ),0) 



COMPILATION CONSIDERATIONS 



Included in this topic are discussions of 
compiler restrictions and storage 
requirements . 



Compiler storage Requirements 



The compiler itself requires a minimum of 
160K bytes of main storage. Approximately 
200 to 300 source statements can be 
compiled when this amount of storage is 
available to the compiler. 



The compiler* s secondary storage 
requirement is 160 tracks on an IBM 2311 
Disk Storage Unit. 



The compiler itself requires a minimum 
of 160K bytes of main storage for compiler 
code and work areas. Approximately 200 to 
300 source statements can be compiled when 
this amount of storage is available to the 
compiler. 

The compiler code includes two tables 
whose sizes are determined at installation 
time. The adcon table NADCON handles 
address constants, parameters and 



Programming Considerations 131 



temporaries, 
message 



If the table is exceeded the 



ADCON TABLE EXCEEDED 

is issued and compilation is terminated. 
The backward connector table CMAJOR is used 
for certain optimization features. It 
receives backward connector information for 
each block in the source program, a block 
being the unit of instructions associated 
with a single user or compiler-generated 
label. If CMAJOR is too small to handle 
all of the blocks in the source program, 
the message 

TABLE EXCEEDED OPTIMIZATION DOWNGRADED 

is issued and the compilation is affected 
as follows: No branching optimization will 
be performed with either OPTIMIZE (1) or 
OPTIMIZE (2). With OPTIMIZE (2), no text 
optimization will be performed and register 
assignment will treat the whole program as 
one loop, as in OPTIMIZE(l). The result is 
longer and less efficient object code. 

If either of these tables overflows 
without having been installed at the 
maximum size, it may be desirable to 
re-install the compiler with a larger size 
specified for the table in question (see 
the publication OS FORTRAN IV (H Extended) 
Comp i ler and L i b ra ry (Mod II) Installati on 
Reference Material , Order No. SC28-6861 for 
details). Note that such a procedure will 
slightly change the amount of main storage 
required for compiler code. 

In the partition or region in which the 
compiler is running, any available space in 
excess of that required by the compiler 
code is used as a work area. In a 
multitasking environment, to limit the 
amount of storage for the compiler plus the 
work area, thereby making more storage 
available for other tasks, the FORTRAN 
programmer can reduce the amount of storage 
to be allocated through use of the SIZE 
option. 

During compilation, if the unused work 
area is more than 10K bytes, the compiler 
prints the following informational message: 

nnnnK BYTES OF CORE NOT USED 

This message indicates how much smaller the 
specified SIZE value could be. This 
message may also be generated when SIZE has 
not been specified; in such a case, the 
message indicates how much smaller a region 
or partition size could be. 

Note that the SIZE option indicates only 
the space required by the FORTRAN option 
and has no effect on space required by 
operating system facilities. The partition 



or region in which the compiler is running 
must be at least 10K bytes larger than the 
specified SIZE value to accommodate 
facilities required by the system, such as 
buffer allocation routines. 

If the SIZE option is specified 
incorrectly, a compiler diagnostic message 
is produced and the SIZE parameter is 
ignored. 

Figure III-3 illustrates a sample 
storage structure using the SIZE option and 
the REGION parameter. 



r 1 

Assume: REGION=200K, PARM=* SIZE(180K) ' 

/r 1 



Compiler Code 



|REGION=200K }\- -|/SIZE(180K) 

I 
j | Work Area 

I 



j. j 



180 



| System-required j 
j facilities 

\L J 200 



l j 

Figure III- 3. Storage Structure Using SIZE 
and REGION 



Compiler Restrictions 

Compiler restrictions are the following: 

1 . For DO loops : 

• The maximum number of nested open DO 
statements is 25 

• The maximum number of implied DOs 
per input/output statement is 20 

2. For FORMAT statements: 

• The maximum value for the repetition 
field (a) is 255. 

• The maximum value for the character 
specification field (w) is 255. 

3. For statement functions: 

• The maximum number of arguments per 
function definition statement is 20. 



132 



• Within a function definition, the 
maximum number of nested references 
to other statement functions is 50. 

• Within a function reference the 
maximum number of nested references 
to other statement functions is 50. 

4. For CALL statements: 

• The maximum number of arguments is 
136; any argument containing a 
subscript is counted as two 
arguments. 

5. For PAUSE statements: 

» The maximum number of characters 
permitted is 255. 

6. For literal constants: 

• The maximum number of characters 
permitted is 255; this restriction 
applies to literal constants 
specified in list-directed input 
statements ( statements with no 
corresponding FORMAT statement) . 



LOAD MODULE CONSIDERATIONS 

Included in this topic are discussions of 

1. Load module restrictions 

2. Boundary alignment considerations 

3. Using names that the compiler 
recognizes as generic. 

Load Module Restrictions 



The following is a list of load module 
restrictions: 

• The minimum record length for records 
on a magnetic tape volume is 18 „ 

• A data set reference number cannot 
exceed the maximum data set reference 
number specified by the installation 
when the system is generated. 



Boundary Alignment Considerations 



Greater efficiency results if the 
programmer specifies proper boundary 



alignment for items in COMMON or 
EQUIVALENCE lists. If items are not 
properly aligned, further processing is 
dependent upon the BOUNDRY option specified 
at program installation time. if 
BOUNDARY=ALIGN was specified, boundary 
alignment is performed through execution of 
a subprogram from the SYS1.LINKLIB library; 
if BOUNDARY= NO ALIGN was specified, the job 
terminates. 



Using Names Recognized by the Compiler as 
Generic or an Alias 



When automatic function selection has been 
requested, the H Extended compiler 
recognizes as generic the list of function 
names given in Appendix H of IBM System/360 
a nd Sys tem/ 370 FORTRAN IV Language, Order 
No. GC28-6515-8, and subsequent revisions. 
Of this list, eight names are aliases; that 
is, they are common abbreviations for 
certain existing function names. In 
program units specifying GENERIC, they are 
also the generic names for the classes of 
function. For example, the name LOG, an 
alias, is recognized as generic for the 
family of natural logarithmic functions. 



In any program unit in which GENERIC has 
been specified, user-supplied external 
procedures whose names coincide with a 
generic name will not be executed unless 
they are "detached;" that is, used in a 
conflicting Type statement or specified in 
an EXTERNAL statement and preceded by an 



amnprcan; 



impJ 



n -n -a t j. n t /-> ^ 
x\Jj«.Jj-»"0 XAAj, 



EXTERNAL SLOG. When a generic name has 
been so detached, it loses its generic 
status. Each member of that family of 
functions must then be referred to 
specifically within the program unit. 



Aliases are recognized as substitute 
specific names even in program units not 
using the automatic function selection 
facility. Therefore, user-supplied 
external procedures whose names coincide 
with aliases for built-in func tions must be 
detached as described above or else they 
will not be executed. For example, if a 
user-supplied function, MAX, is to be used, 
the name MAX must be detached. In 
references to the FORTRAN- supplied function 
within the program unit, the specific 
function name, MAXO, rather than the alias, 
MAX must be used. The aliases for built-in 
function names are: MAX for MAXO, MIN for 
MINO, and IMAG for AIMAG. 



Programming Considerations 133 



AUTOMATIC PRECISION INCREASE FACILITY 



The Automatic Precision Increase facility 
of the FORTRAN compiler automatically 
converts single precision floating point 
calculations to double precision and/or 
double precision to extended precision. It 
is designed to be used with programs 
originally written for earlier computers 
that offered greater precision than that 
available with System/360; the conversion 
facility may be used to convert programs 
where this extra precision may be of 
critical importance. 

The facility is not meant to be used 
with new programs (those written for 
System/360 compilers) . If such programs 
require operations with greater precision, 
they should be coded using the precision 
forms available in FORTRAN. Although the 
facility will convert new programs, the 
cost in programmer and compilation time and 
the increase in storage space makes its use 
inefficient. 

No recoding of source programs is 
necessary to take advantage of the 
facility. Conversion is requested through 
an EXEC statement option at compilation 
time. 



THE CONVERSION PROCESS 



2. Double precision items to be promoted 
to extended precision items, that is, 
REAL+8 to REAL+16 and COMPLEX+16 to 
COMPLEX* 32. 

Note that single precision items cannot be 
increased directly to extended precision 
items. 

Promotion converts the following: 

Constants ; Single-precision real and 
complex constants are promoted to double 
precision. Double-precision real and 
complex constants are promoted to extended 
precision. Logical and integer constants 
are not affected. 

Examples of promoted constants are: 



Constant 

3.0 

4.24E5 

4.2UD5 

(3.2,3.1416E0) 



Promoted Form 
of Constant 

3. 0D0 
4.24D5 

4. 24Q5 

(3.2D0, 3.1416D0) 



Variables : REAL* 4 and COMPLEX* 8 variables 
are promoted to REAL* 8 and COMPLEX* 16, 
respectively. REAL* 8 and COMPLEX+16 
variables are promoted to REAL+16 and 
COMPLEX* 3 2, respectively. 

Examples of promoted variables are: 



The conversion process comprises two 
functions: promotion and padding. 
Promotion is the process of converting 
items from one precision to a higher 
precision, for example, from single 
precision to double precision. The 
promotion function is described in greater 
detail below. Padding is the process of 
doubling the storage size of non-promoted 
items. Padding helps the user preserve the 
size relationships between promoted and 
non-promoted items sharing storage. 



Promotion 



The user may request either or both of the 
following conversions: 

1. Single precision items to be promoted 
to double precision items, that is, 
REAL* 4 to REAL* 8 and COMPLEX* 8 to 
COMPLEX+16. 



Variable 
REAL STAR, 
MOON, PLANET 



Promoted Form 

of Variable 

REAL* 8 STAR, 
MOON, PLANET 



IMPLICIT IMPLICIT 
REAL*8(S, T, U) REAL+16 (S, T, U) 



COMPLEX* 8 
A, B, C, D 



COMPLEX+16 
A, B,C,D 



Functions : The correct FORTRAN-supplied 
functions are substituted when a program is 
converted. For example, a reference to SIN 
causes the DSIN function to be substituted 
if double precision calculation is to be 
performed; a reference to DINT causes QINT 
to be substituted if extended precision 
calculation is performed. Table III-l 
lists FORTRAN-supplied built-in functions 
that are substituted. Table III-2 lists 
FORTRAN-supplied library functions that are 
substituted. Function values are promoted 
in the same manner as constants; that is, 
single precision values are promoted to 
double precision, double precision values 
are promoted to extended precision. 



134 



Previously compiled subprograms must be 
recompiled to be converted to the correct 
precision. For example, if a user-supplied 
subprogram accepts only single precision 
arguments and it is to be used with a 
program being converted to double 
precision, it must be recompiled using API 
to accept double precision arguments. 



EXEC STATEMENT OPTIONS 



Note, however, that padding reduces the 
efficiency of input/output operations for 
padded arrays. 

AUTODBL ( DEL ) 

to indicate promotion (but no padding) 
of both single and double precision 
items. Items of REAL* 4 and COMPLEX* 8 
types are converted to REAL* 8 and 
COMPLEX* 16. Items of REAL* 8 and 
COMPLEX* 16 types are converted to 
REAL* 16 and COMPLEX* 32. 



The programmer requests the automatic 
precision increase facility through the 
PARM parameter in the EXEC statement 
calling the compiler. The PARM parameter 
specifies the AUTODBL subparameter to 
indicate the form that the conversion will 
take and the ALC subparameter to indicate 
whether storage alignment is to take place. 



AUTQD BL Subparameter 



The AUTODBL subparameter takes one of the 
following forms: 



AUTODBL (NONE) 

to indicate no conversion, 
the default condition. 



This is 



AUTODBL (DBL4) 

to indicate promotion of single 
precision items only. 

AUTODBL ( DBL8 ) 

to indicate promotion of double 
precision items only. 

Note : If AUTODBL is specified, and an 
error in coding the parameter is detected, 
the compiler substitutes the option DBLPAD8 
as a default. 



For most programs, one of the above 
forms is sufficient. The following form 
offers greater flexibility to the user who 
wishes to tailor the conversion process to 
a particular program; however, it also 
increases the chance of error and should be 
used with care. 



AUTODBL (DBLP AD) 

to indicate promotion and padding of 
single and double precision items. 
REAL* 4, REAL* 8, COMPLEX* 8 and 
COMPLEX+16 types are converted. Items 
of other types are padded if they 
share storage space with converted 
items. 

AUTODBL (DBLP AD 4 ) 

to indicate promotion of single 
precision items only, and padding of 
other items that share storage with 
promoted items. 

AUTODBL ( DBLPAD8 ) 

to indicate promotion of double 
precision items only, and padding of 
other items that share storage with 
promoted items. 

The promotion and padding options, 
DBLPAD, DBLPAD4, and DBLPAD8, ensure that 
the storage-sharing relationship that 
existed prior to conversion is maintained. 



AUTODBL (abcde) 

indicates that the program is to be 
converted according to the value of 
abcde, a five-position field. Each 
position is coded with a numeric value 
that specifies how a particular 
conversion function is to be 
perf ormed* 

The leftmost position (position a) 
describes the promotion function, that 
is, whether promotion is to occur and, 
if so, which items are to be promoted. 
The second position (position b) 
describes the padding function, that 
is, whether padding is to occur and, 
if so, the sections in the program 
(such as COMMON or argument lists) 
where padding is to take place. The 
third, fourth, and fifth positions 
describe whether padding is to occur 
for particular types (LOGICAL, 
INTEGER, and REAL, respectively) 
within the program sections specified 
in position b. 



Automatic Precision Increase Facility 135 



Table III-l. Built-in Functions — Substitution of Single and Double Precision 
r 











Corresponding | 


_ _ _ 1 

Corresponding | 


Sinql 


e Precision Function | Double Precision 


Function | Extended Precision Function | 
-4- J 




Argument 


Function 




Argument 


Function 




Argument 


Function | 


Name 


Type 
REAL* 4 


Value Type 


Name 
DMOD 


Type 
REAL* 8 


Value Type 


Name 
QMOD 


Type 
REAL* 16 


Value Type| 


AMOD 


REAL* 4 


REAL* 8 


REAL+16 | 


ABS 


REAL* 4 


REAL* 4 


DABS 


REAL* 8 


REAL* 8 


QABS 


REAL* 16 


REAL+16 | 


INT 


REAL* 4 


INT* 4 


IDINT 


REAL* 8 


INT* 4 


IQINT 


REAL* 16 


INT+4 | 


AINT 


REAL* 4 


REAL* 4 


DINT 


REAL* 8 


REAL* 8 


QINT 


REAL* 16 


INT* | 


AMAXO* 


INT + 4 


REAL* 4 














AMAX1 


REAL* 4 


REAL* 4 


DMAX1 


REAL* 8 


REAL* 8 


QMAX1 


REAL+16 


REAL+16 | 


MAX1 1 


REAL* 4 


INT* 4 














AMINOi 


INT* 4 


REAL* 4 














AMIN1 


REAL* 4 


REAL* 4 


DMIN1 


REAL* 8 


REAL* 8 


QMIN1 


REAL* 16 


REAL+16 | 


MIN1 1 


REAL* 4 


INT* 4 














FLOAT 


INT* 4 


REAL* 4 


DFLOAT 


INT*4 


REAL* 8 


QFLOAT 


INT* 4 


REAL+16 | 


IFIX 


REAL* 4 


INT+4 


IDINT 


REAL* 8 


INT + 4 


IQINT 


REAL+16 


INT+4 | 


HFIX 1 


REAL* 4 


INT* 2 














SIGN 


REAL* 4 


REAL* 4 


DSIGN 


REAL* 8 


REAL* 8 


QSIGN 


REAL*16 


REAL+16 | 


DIM 


REAL* 4 


REAL* 4 


DDIM 


REAL* 8 


REAL* 8 


QDIM 


REAL+16 


REAL+16 | 


REAL 


COMPLEX* 8 


REAL* 4 


DREAL 


C0MPLEX*16 


REAL* 8 


QREAL 


COMPLEX* 3 2 


REAL+16 | 


AIMAG 


COMPLEX* 8 


REAL* 4 


DIMAG 


COMPLEX* 16 


REAL* 8 


QIMAG 


COMPLEX* 3 2 


REAL+16 | 


CMPLX 


REAL* 4 


COMPLEX* 8 


DCMPLX 


REAL* 8 


COMPLEX* 16 


QCMPLX 


REAL* 16 


COMPLEX* 32 | 


CONJG 


COMPLEX* 8 


COMPLEX* 8 


DCONJG 


COMPLEX* 16 


COMPLEX* 16 


QCONJG 


COMPLEX* 32 


COMPLEX* 32 | 



J- -L 

^The 
prec 



corresponding double precision 
ision function is expanded as 



function does not exis 
though the double preci 



t by name, but the single 
sion function existed. 



L J 

Table III-2. Library Functions — Substitution of Single and Double Precision 

r t t T 











Correspondi 


ng 




Corresponding 


Singl 


e Precision Function 

j 


Double Precision 

L _ 


Function 

j 


Extended Precision Function 

L 




Argument 


Function 


r 


Argument 


1 
Function 


1 


Argument 


Function 


Name 


Type 
REAL* 4 


Value Type 
REAL* 4 


Name 
DEXP 


Type 
REAL* 8 


Value Type 
REAL* 8 


Name 
QEXP 


Type 
REAL+16 


Value Type 


EXP 


REAL+16 


CEXP 


COMPLEX* 8 


COMPLEX* 8 


CDEXP 


COMPLEX* 16 


COMPLEX* 16 


CQEXP 


COMPLEX* 3 2 


COMPLEX* 3 2 


ALOG 


REAL* 4 


REAL* 4 


DLOG 


REAL* 8 


REAL* 8 


QLOG 


REAL+16 


REAL+16 


CLOG 


COMPLEX* 8 


COMPLEX* 8 


CDLOG 


COMPLEX* 16 


COMPLEX* 16 


CQLOG 


COMPLEX* 3 2 


COMPLEX* 3 2 


ALOG10 


REAL* 4 


REAL* 4 


DLOG10 


REAL* 8 


REAL* 8 


QLOG10 


REAL+16 


REAL+16 


ARSIN 


REAL* 4 


REAL* 4 


DARSIN 


REAL* 8 


REAL* 8 


QARSIN 


REAL+16 


REAL+16 


ARCOS 


REAL* 4 


REAL* 4 


D ARC OS 


REAL* 8 


REAL* 8 


QARCOS 


REAL+16 


REAL+16 


ATAN 


REAL* 4 


REAL* 4 


DATAN 


REAL* 8 


REAL* 8 


QATAN 


REAL+16 


REAL+16 


AT AN 2 


REAL* 4 


REAL* 4 


DATAN2 


REAL* 8 


REAL* 8 


Q ATAN 2 


REAL+16 


REAL+16 


SIN 


REAL* 4 


REAL* 4 


DSIN 


REAL* 8 


REAL* 8 


QSIN 


REAL+16 


REAL+16 


CSIN 


COMPLEX* 8 


COMPLEX* 8 


CDSIN 


COMPLEX* 16 


COMPLEX* 16 


CQSIN 


COMPLEX* 3 2 


COMPLEX* 3 2 


COS 


REAL* 4 


REAL* 4 


DCOS 


REAL +8 


REAL* 8 


QCOS 


REAL+16 


REAL+16 


CCOS 


COMPLEX* 8 


COMPLEX* 8 


CDCOS 


COMPLEX* 16 


COMPLEX* 16 


CQCOS 


COMPLEX* 3 2 


COMPLEX* 3 2 


TAN 


REAL* 4 


REAL* 4 


DTAN 


REAL* 8 


REAL* 8 


QTAN 


REAL+16 


REAL+16 


COT AN 


REAL* 4 


REAL* 4 


DCOTAN 


REAL* 8 


REAL* 8 


QCOTAN 


REAL+16 


REAL+16 


SQRT 


REAL* 4 


REAL* 4 


DSQRT 


REAL* 8 


REAL* 8 


QSQRT 


REAL+16 


REAL+16 


CSQRT 


COMPLEX* 8 


COMPLEX* 8 


CDSQRT 


COMPLEX* 16 


COMPLEX* 16 


CQSQRT 


COMPLEX* 3 2 


COMPLEX* 32 


TANH 


REAL* 4 


REAL* 4 


DTANH 


REAL* 8 


REAL* 8 


QTANH 


REAL*16 


REAL+16 


SINH 


REAL* 4 


REAL* 4 


DSINH 


REAL* 8 


REAL* 8 


QSINH 


REAL+16 


REAL+16 


COSH 


REAL* 4 


REAL* 4 


DCOSH 


REAL*8 


REAL* 8 


QCOSH 


REAL+16 


REAL+16 


ERF 


REAL* 4 


REAL* 4 


DERF 


REAL* 8 


REAL* 8 


QERF 


REAL+16 


REAL+16 


ERFC 


REAL* 4 


REAL* 4 


DERFC 


REAL* 8 


REAL* 8 


QERFC 


REAL* 16 


REAL+16 


GAMMA 1 


REAL* 4 


REAL* 4 


DGAMMA 1 


REAL* 8 


REAL* 8 








ALGAMA 1 REAL*4 


REAL* 4 


DLGAMA 1 


REAL* 8 


REAL* 8 








CABS 


COMPLEX* 8 


REAL +4 


CD ABS 


COMPLEX*! 6 


REAL* 8 


CQABS 


COMPLEX* 3 2 


REAL+16 



j. X J. .J 

A The extended precision equivalences of these functions do not exist. In promoting 
REAL* 8 to REAL+16 , the double precision function will be used. 

L J 



136 



All five positions must be coded; 
if a function is to be omitted, the 
corresponding position is coded with a 
zero. The values for each position 

arp ,q<^ 'FqI 1 QW* 5 ; 

• Position a, the promotion function: 

Value Mea ning 

No promotion 



• Position d, padding integer 
variables in program sections 
specified in position b: 

Value Meanin g 

Pad no integer variables 



1 Pad INTEGER* 2 variables only 



Promote REAL* 4 ana uOMir'iiiiX* » 
items only 

Promote REAL* 8 and 
COMPLEX* 16 items only 



2 Pad INTEGER*** variables only 



3 Pad all integer variables 



promote all real and complex 
items 



• Position b, the padding function: 

Value Meaning 

No padding 

1 Pad COMMON statement and 
argument list variables 



Pad EQUIVALENCE statement 
variables equivalenced to 
promoted variables 



• Position e, padding real and complex 
variables in program sections 
specified in position b: 

Value Meaning 

Pad no real or complex 
variables 



1 Pad REAL* 4 and COMPLEX* 8 
variables 



2 Pad REAL+8 and C0MPLEX*16 
variables 



Pad COMMON and EQUIVALENCE 
statement variables related 
to promoted variables and 
argument list variables 



Pad REAL* 4, REAL* 8, 
COMPLEX* 8, and COMPLEX* 16 
variables 



Pad EQUIVALENCE statement 
variables that do not relate 
to variables in COMMON 
statements 



Pad variables everywhere 



Pad REAL*16 and COMPLEX* 3 2 

vaLxauica 



Pad REAL* 4 , COMPLEX* 8, 
REAL*16 # and COMPLEX* 3 2 
variables 



The code specified in this position 
determines in which areas of a program 
the padding requested by positions c 
to e is to take place. 



• Position c, padding logical 
variables in program sections 
specified in position b: 

Value Meaning 

Pad no logical variables 

1 Pad LOGICAL+1 variables only 

2 Pad LOGICAL* 4 variables only 

3 Pad all logical variables 



Pad REAL*8, REAL*16, 
COMPLEX* 16, and COMPLEX* 3 2 
variables 



Pad all real and complex 
variables 



Note that promotion overrides padding. 
For example, if the first position 
specifies promotion to occur for single 
precision items, REAL+4 and COMPLEX+8 items 
are promoted regardless of the padding 
function specified in position e. 



Automatic Precision Increase Facility 137 



Coding Examples 

The AUTODBL(abcde) settings that correspond 
to the mnemonic options are: 

NONE(OOOOO) 

DBLOOOOO) 

DBL4 (10000) 

DBL8 (20000) 

DBLPAD(33334> 

DBLPAD4 (13336) 

DBLPAD8( 23335) 

The following examples illustrate other 
possible selections of the AUTODBL(abcde) 
format. 

Example 1 : AUTODBL( 12330) 

Promotion is performed and padding is 
performed for all EQUIVALENCE 
statements, logical variables, and 
integer variables. 

Example 2 ; AUTODBL( 01001) 

No promotion is performed, but padding 
is performed for all REAL* 4 and 
COMPLEX+8 variables in common blocks and 
argument lists. This code setting 
permits a program not requiring double 
precision accuracy to link with a 
subprogram compiled with the option 
AUTODBL(DBL). 

Example 3 : AUTODBH 01337) 

No promotion is performed, but padding 
is performed for all integer, logical, 
real, and complex variables that are in 
COMMON or are used as subprogram 
arguments. This code setting permits a 
non-converted program to link with a 
program converted with the option 
AUTODBL(DBLPAD4) . 



Ordinarily, to increase execution-time 
efficiency, COMMON statements are coded so 
that variables in COMMON blocks are aligned 
on proper boundaries: doubleword variables 
on doubleword boundaries, fullword 
variables on fullword boundaries, and 
halfword variables on halfword boundaries. 
When the conversion facility is used, these 
alignments may become altered. The ALC 
option restores alignment. 

The ALC option should be used with care 
for it may cause previously matched COMMON 
blocks to become mismatched. For example, 
consider the two COMMON statements below 
where the variable INTER is to be shared: 



Program 1 
REAL* 8 R8 
COMMON/X/A, R8, INTER 



Progr am 2 
REAL* 4 R4 
COMMON/X/A, I, R4, INTER 



With neither the AUTODBL nor the ALC 
option specified, both occurrences of the 
variable INTER will be at an offset of 12 
bytes from the start of COMMON block X. 

If ALC alone is used, INTER would be 16 
bytes from the start of COMMON X in Program 

1 since R8 would have been placed on a 
double word boundary. COMMON X in Program 

2 would have been unaffected. 

If AUTODBL(DBL) and ALC are specified, 
INTER would be 16 bytes from start of block 
X in Program 1 and 24 bytes from start in 
Program 2. (This is because of the 
promotion of REAL* 4 to REAL* 8 and 
subsequent alignment. ) 

It is recommended that ALC be used only 
when the COMMON variables are identical in 
type. 



PROGRAMMING CONSIDERATIONS WITH API 



This section provides a brief discussion of 
how use of the Automatic Precision Increase 
facility affects program processing. 



ALC Subparameter 



The ALC subparameter is used to specify 
storage alignment. It takes one of the 
forms: 



ALC 
NOALC 



to indicate whether storage alignment 
is to take place. NOALC is the 
default value. 



Effect on COMMON or EQUIVALENCE Data Values 



Promotion and padding operations preserve 
the storage sharing relationships that 
existed before conversion. However, in 
storage sharing items, data_yalues are 
preserved only for the following: 

1. Variables having the same length 

2. Real and complex variables having the 
same precision 



138 



For example, the following items retain 
value sharing relationships: 

LOGICAL* 4 and INTEGER* 4 (same length) 

REAL+4 and COMPLEX* 8 (same precision) 

The following items do not retain value 
sharing relationships: 

INTEGER* 2 and INTEGER*4 (different lengths) 

REAL*8 and C0MPLEX*8 (different precision) 

Effect on Literal Constants 



Care should be exercised when specifying 
literal constants as data initialization 
values for promoted or padded variables, as 
subprogram arguments, or in NAMELIST input. 
For example, literals should be entered 
into arrays on an element by element basis 
rather than as one continuous string. 
Consider the following statements: 

DIMENSION A(2),B(2) 

DATA A/ , ABCDEFGH'/,B(1)/'IJKL , /,B(2) 
/• MNOP 1 / 



Array B will be initialized correctly but 
not array A, because padding takes place at 
the end of each element. 



Effect on Prog r ams Calling Subprograms 



FORTRAN main programs and subprograms must 
be converted so that variables in COMMON 
retain the same relationship to guarantee 
correct linkage during execution. The 
recommended procedure is to compile all 
program units using AUTODBL(DBLPAD) . If an 
option other than DBLPAD is selected, care 
must be taken if the COMMON variables in 
one program unit differ from those in 
another; COMMON variables that are not to 
be promoted should be padded. 



arguments, the next higher precision 
subprograms are substituted for the 
original ones. The extended symbol 
dictionary, used by the linkage editor 
to resolve references between program 
units, will contain the double and 
extended precision names for each 
single and double precision library 
program promoted. 



2. If the programmer has supplied his own 
function for a FORTRAN-supplied 
function, but has neglected to detach 
the name through an EXTERNAL 
statement, the wrong function may be 
executed. 

Example : AUTODBL ( DB L4 ) 

REAL+4 X, Y 
4 Y=SIN(X) 
STOP 
END 



FUNCTION SIN(X) 



RETURN 
END 

In this example, because the compiler 
cannot recognize SIN as a 
user-supplied function, it substitutes 
the name of the FORTRAN-supplied 
function DSIN in statement 3. 
However, the compiler does not change 
the function definition statement; the 
name remains SIN. At execution time 
the user-supplied function SIN is 
ignored and the FORTRAN-supplied 
function DSIN is executed in its 
place. 

The programmer can avoid this 
confusion either by making sure he 
detaches the name SIN, preceded by an 
ampersand, in an EXTERNAL statement or 
by changing the name of the function 
to DSIN. 



Any non-FORTRAN external subprogram 
called by a converted program unit should 
be recoded to accept padded and promoted 
arguments. 



Effect on FORTRAN Library Subprograms 



1. If a call to a FORTRAN library 
subprogram contains promoted 



Effect on CALL DUMP or CALL PDU MP 
Statements 



If a CALL DUMP or CALL PDUMP statement 
requests a dump format of either REAL*4 or 
COMPLEX+8, output from a converted program 
is shown in single precision format. Each 
item is displayed as two single precision 
numbers rather than as one double precision 
number. 



Automatic Precision Increase Facility 139 



For variables that are promoted, the 
first number is approximately the value of 
the stored variable; the second number is 
meaningless. 

For variables that are padded, the first 
number is exactly the value of the 
variable; the second number is meaningless. 



Effect o n Dir ect-A ccess Input/Output 
Processing 



When a DEFINE FILE statement has been 
specified, any record exceeding the maximum 
specified record length causes record 
overflow to occur. 

For converted programs, the programmer 
should check the record size coded in the 
statement to determine if it can handle the 
increased record lengths. If not 
sufficient, the size should be increased 
appropriately. 



acceptable to converted programs if the I/O 
list contains promoted variables. 



To make an unconverted data set 
accessible to the converted program, the 
programmer should code BFALN=F in the DCB 
parameter at load module execution time, 
causing data to be transmitted in its 
unconverted form. For example, assume that 
a program contains the statement: 



WRITE (3)1, J, (ARRAY (N) # N=1, J) 



If the program is converted such that ARRAY 
contains promoted items, the programmer 
should code the following DD statement to 
write unconverted ARRAY records: 



//FT03Fxxx 



DD 



DCB=(BFALN=F... ). .. 



for: 



The BFALN parameter is not specified 



Effect on Asy nch rono us Input/Output 
Processing 



• Programs and data sets having the same 
conversion characteristics, 



Extreme care should be exercised in using 
the Automatic Precision Increase facility 
for programs containing asynchronous 
input/output statements. 

The asynchronous input/output facility 
transmits the number of bytes as specified 
by the transmitting or receiving areas. 
These areas for any given data set must 
have the same characteristics regarding 
promotion and padding; e.g., both must be 
padded or both must be promoted. 



Effe ct on Unf ormat ted Input/Output Data 
Sets 



Unformatted input/output data sets which 
have not been converted are not directly 



• Formatted data sets, regardless of 
conversion characteristics; the FORMAT 
statement controls the correct 
transmission of data. 



Effect on the Storage Map 



The storage map produced by the MAP option 
contains the following codes: 



Code 
D 

P 

* 



Meaning 

Promoted variable 

Padded variable 

Promoted library function name 



140 



LINKAGE EDITOR OVERLAY FEATURE 



Overlay is a feature of linkage editor 
processing that allows the FORTRAN user to 
reduce the main storage requirements of his 
program by breaking it up into two or more 
segments that need not be in main storage 
at the same time. These segments can be 
assigned the same storage addresses and can 
be loaded at different times during 
execution of the program. The user 
specifies linkage editor control statements 
to indicate the relationship of segments 
within the overlay structure. FORTRAN 
programs run under VS seldom require 
overlay processing. 



SEGMENTS 



The relationships among the program units 
in the overlay program described in the 
preceding paragraphs can be graphically 
represented by an overlay "tree" structure 
as shown in Figure III-6. Each "branch" of 
the overlay tree consists of a separately 
loaded unit of the program to which the 
linkage editor assigns a number. Such 
overlay units, or segments, may contain one 
or more subprograms totaling 524,288 bytes 
(512K). 



MAIN 



DESIGNING A PROGRAM FOR OVERLAY 



Programs are placed in an overlay structure 
according to the size, frequency of use, 
and logical relationships between the 
proqram units that they comprise. The 
basic principle of overlay is illustrated 
by the simple example in Figure III-4. 
This figure shows a FORTRAN program 
consisting of a main program and two large 
subprograms named SUBA and SUBB. Normally, 
all three program units would be loaded 
into main storage at the same time and 
would remain there throughout execution of 
the entire program. However, if there is 
not enough main storage space available to 
accommodate all three program units at 
once, and if SUBA and SUBB do not have to 
be in main storage at the same time, the 
user could design an overlay structure in 
which the MAIN routine resides in main 
storage at all times, while subprograms 
SUBA and SUBB make use of the remaining 
space as they are needed. 



Figure I II- 5 shows what happens at 
execution time to the program in Figure 
III- 4. The MAIN routine is loaded and 
processing begins. When the MAIN routine 
calls SUBA, SUBA is loaded and processing 
continues until SUBB is called. SUBB then 
overlays SUBA in main storage and remains 
there until SUBA is called again. The main 
storage requirements of the program are 
thus reduced from the total number of bytes 
in all three program units to the total 
number of bytes in the MAIN program plus 
the larger of the two subprograms. 



SUBA 
SUBB 



Figure III-4, 



A FORTRAN Program Containing 
Three Program Units 



MAIN STORAGE 



MAIN 

T T T 



SUBA 



SUBB 



SUBA 



Problem 
program 
area 



l J 

Time >n 

Figure III- 5. Time/Storage Map of Program 
Described in Figure III- 4 



The first segment in any overlay program 
is called the root segment. The root 
segment remains in main storage at all 



Linkage Editor Overlay Feature 141 



times during execution of the program, 
must contain: 



It 



The program unit which receives control 
at the start of processing. Usually 
this is the main routine in which 
processing begins at the entry point 
named MAIN. 

Any program units which should remain 
in main storage throughtout processing. 
For greater efficiency, subprograms 
that are frequently called should also 
be placed in the root segment if 
possible. 

Any program units containing DEFINE 
FILE statements. 

Certain information needed by the 
operating system to control the overlay 
operation. Like FORTRAN library 
subprograms, this information is 
automatically included in the root 
segment by the linkage editor. 



PATHS 



The relationships among the segments of an 
overlay program are expressed in terms of 
"paths. " A path consists of a given 
segment and any segments between it and the 
root segment. The root segment is thus a 
part of every path, and when a given 
segment is in main storage, all segments in 
its path are also in main storage. The 
simple program in Figure III- 6 is made up 
of only two paths as shown in Figure III-7. 



The paths of an overlay program are 
determined by the dependencies between 
program units. A program unit is 



Path 1 

r 1 

| MAIN | 
L__ T J 

I 
I 

r— L 1 

I SUBA | 

L J 



Path 2 

r t 

| MAIN | 



r— L — t 

J SUBB j 
L J 



Figure III-7. Overlay Paths Implied by 
Tree Structure in Figure 
III-6 



considered to be dependent on any other 
program unit which it calls or whose data 
it must process. 



Figure III-8 shows a FORTRAN program in 
an overlay tree structure. The paths 
implied by that structure are illustrated 
in Figure III- 9. The MAIN routine and 
subprograms SUBl and SUB2 remain in main 
storage for the duration of execution time; 
they occupy the root segment. The segment 
containing subprograms SUB3 and SUB4 use 
the same area of main storage as the 
segment containing subprograms SUB11 and 
SUB12. Likewise, the main storage area 
used by the segment containing SUB5, SUB6, 
and SUB7 are used by the segment containing 
SUB8 and SUB9, as well as by the segment 
containing SUB10. Figure 111-10 is a 
time/storage map of the program shown in 
Figures III-8 and III-9. 



The structure in Figures III-8 and III-9 
consists of segments numbered 1 through 6, 
with segment 1 being the root segment. 
Segments 2 and 6 have the same relative 
origin; that is, they will start at the 
same location when in main storage. This 
origin has been given the symbolic name 
ALPHA by the user (on an OVERLAY control 
card) . The relative origin of segments 3, 
4, and 5 has been given the symbolic name 
BETA. 







ROOT 
Segment 1 


1 
J 




Segment 2 


r ~ 
| MAIN 

L T 

1 

_ ± 


Segment 3 


r 

1 

JL _ . 

SUBA 


■1 

1 
1 


ALPHA 




1 

r x 

| SUBB 
L 



Figure III-6. 



Overlay Tree Structure of 
Program Described in Figure 
III-4 



The relative origin of the root segment, 
also called the relocatable origin, is 
assigned at 0. The relative origin of any 
segment other than the root segment is 
determined by adding the lengths of all 
segments in its path, including the root 
segment. When the program is loaded for 
execution, the first location of the root 
segment (the relocatable origin of the 
program) is assigned to an absolute storage 
address. All other origins are 
automatically increased by the number of 
that storage address, i.e., given an 
address relative to the address assigned to 
the root segment. 



142 



Segment 2 



I 
±. 

| SUB3 | 
|. ., 

j SUB4 | 



ROOT 
Segment 1 

r n 

| MAIN | 

I- -I 

| SUB1 | 

i- ^ 

| SUB2 | 
L T .__j 

I 
J. 

ALPHA 



Segment 6 



I 

r i 1 

| SUB11 | 

f "I 

j SUB12 | 
L j 



COMMUNICATING BETWEEN SEGMENTS 



Overlay segments can be related to one 
another either by being inclusive or 
exclusive. Inclusive segments are those 
which can be in main storage 
simultaneously; in other words, those which 
lie in the same path. Exclusive segments 
are those which lie in different paths. 
Thus, in the program shown in Figures III-8 
and III- 9, segments 2 and 5 are inclusive, 
while segments 2 and 6 are exclusive. 



Inclusi 1 



le j. erences 



I 
Segment 3 Segment 4 Segment 5 



r 
1 


T- 
1 


- i 
1 


r ■«■ 1 

j SUB5 | 


r A t 

j SUB8 | 


r ± , 

| SUB10 j 


i- ^ 


h ^ 


L J 


| SUB6 | 


| SUB9 | 




h -1 


L J 




| SUB7 | 






L __ J 







Figure III- 8. Overlay Tree Structure 
Having Six Segments 



An inclusive reference is a reference from 
a segment in main storage to a subprogram 
which will not overlay the calling segment. 
When a CALL is made from a program unit in 
one segment to a program unit in an 
inclusive segment, control may be returned 
to the calling segment by means of a RETURN 
statement. 



When a CALL is issued to a subprogram 
which is higher (closer to the root 
segment) on the overlay tree, the called 
subprogram must return control to the 
calling segment by a RETURN statement 
before any exclusive overlay segments may 
be loaded. 



Path 1 

MAIN 

SUB1 



SUB2 



x_. 

SUB3 



SUB4 

7 _- 



-L_. 

SUB5 



SUB6 
SUB7 



Segment 1 
(ROOT) 



Path 2 

r i 

| MAIN j 



— ^ 

| SUBl | 

j. 4 

I SUB2 | 



I 



h 



SUB3 | 
.| 



Segment 2 | SUB 4 | 

L , J 



r x 1 

| SUB8 | 

j- -j Segment 4 

Segment 3 | SUB9 | 

L J 



Path 3 

r i 

j MAIN j 



h 



-I 



Path 4 

r 1 

I MAIN I 



H 



SUBl | 
j. i 

| SUB2 | 
L T J 

I 



r - 1 1 

I SUB3 I 



| SUB4 | 
I ,. J 



r x 1 

| SUB10 | Segment 5 
l J 



j. 

| SUBl | 
j. .| 

| SUB2 | 



r— -•»■— n 
| SUB11 | 

|- -j Segment 6 

j SUBl 2 | 

L J 



Figure III-9. Overlay Paths Implied by Tree Structure in Figure III-I 



Linkage Editor Overlay Feature 143 



Exclusive References 



An exclusive reference, one made in any 
seqment to another segment which will 
overlay it ( can be either valid or invalid. 



An exclusive reference is considered 
valid only if there is a reference to the 
called routine in a segment common to both 
the segment to be loaded and the segment to 
be overlaid. Assume, for example, in 
Fiqure III-ll that the main program (common 
segment) contains a call to Segment A but 
not to Segment B. A reference in Segment B 
to a routine in Segment A is valid because 
of the inclusive reference between the 
common segment and Segment A. (A table in 
the common segment, supplied by the linkage 
editor, contains the address of Segment A. 
The overlay does not destroy this table. ) 
An exclusive reference in Segment A to a 
routine in Segment B is invalid since the 
common segment contains no reference to 
Segment B. 

Both valid and invalid exclusive 
references are considered errors by the 
linkage editor; however, the user can allow 
a program containing a valid exclusive 
reference to be executed. (See the 
discussion of XCAL and LET options later in 
this chapter. ) Programs containing invalid 
exclusive references are never executable. 
For more detailed information on exclusive 
references, see the appropriate linkage 
editor and loader publication, as listed in 
the Preface. 



INCLUSIVE 




r 

| COMMON 


l 

1 






REFERENCE 




^\ Segment 
L T 

1 

x 


1 
.J 






/ 1 










1 


y i 


1 
j 






r" 
L 


1 
J 


r 

| Segment A 

L 


1 

Segment B | 






EXCLUSIVE 












REFERENCE 









Figure III-ll. Communication Between 
Overlay Segment 



COMMON AREAS 



The linkage editor treats all FORTRAN 
COMMON areas as separate subprograms. When 
modules containing COMMON areas are 
processed by the linkage editor, the COMMON 
areas are collected. That is, when two or 
more blank (unnamed) COMMON areas are 
encountered in the input to the linkage 
editor, only the largest of them is 
retained in the output module. (In the 
case of named COMMON areas, the question of 
different lengths does not arise since all 
named COMMON areas of the same name must be 
the same length. ) 



THE OVERLAY PROCESS 



MAIN STORAGE 



Segment 1 (ROOT) 



Segment 2 



| Segment 
I 6 



I. T T + . 

| | SEGMENT | 
I Segment j 5 j 

Segmentj 4 |- J 

3 I- J 

j 



L 

Time 



.j 
->n 



Problem 
Program 
Area 



Figure 111-10. 



Overlay Configuration of 
Program Described in 
Figure III-8 



Overlay is initiated at execution time in 
response to a reference to a subprogram 
which is not already in main storage. The 
subprogram reference may be either a 
FUNCTION name or a CALL statement to a 
SUBROUTINE name. When the reference is 
executed, the overlay segment containing 
the required subprogram, as well as any 
segments in its path not currently in main 
storage, is loaded. 

When a segment is loaded, it overlays 
any segment in storage with the same 
relative origin. It also overlays any 
segments that are lower (farther from the 
root segment) in the path of the overlaid 
segment. For example, if segments 1, 2, 
and 3 in Figures III-8 and III-9 are in 
main storage when the main program executes 
a call to subprogram SUB11, segment 6 is 
called into main storage and segments 2 and 
3 will not be available for as long as 
segment 6 is in main storage. 

Whenever a segment is loaded it contains 
a fresh copy of the program units that it 
comprises; any data values that may have 



144 



been established or altered during previous 
processing are returned to their initial 
values each time the segment is loaded. 
Thus, data values that are to be retained 
for longer than a single load phase should 
be placed in the root segment. 



Overlay is not initiated when a return 
is made from a subprogram or when a segment 
in main storage executes a reference to a 
subprogram that is already in main storages 



In an overlay program, when blank or 
named COMMON areas are encountered by the 
linkage editor, they are collected as 
described above. Their ultimate location 
in the output module depends upon which 
linkage editor control statements are used 
in the building of the overlay structure 
(see the discussion of linkage editor 
control statements below) . Overlay 
structures built without the use of INSERT 
statements (in which the program units for 
each segment are included between OVERLAY 
statements) produce an output module in 
which the linkage editor "promotes" the 
COMMON areas automatically. The promotion 
process places each COMMON area in the 
lowest segment on the overlay tree which 
will always be in main storage with any 
segment containing a reference to it. 



r x 

COMMONB 



h 



SUB5 



SUB6 



SUB 7 



I 

r ■«■ 1 

I COMMONA j 

I SUB3 | 
J. .J 

I SUB4 I 
L T J 

i 



r i 

| MAIN | 

1- -I 

| SUB1 | 
j. J 

j SUB2 | 
L T j 

I 

L 



r X 



r - i r - 1 

| SUB8 | | COMMONB | 

J. .J j. .] 

| SUB9 | j SUB10 | 

L J L J 



r x — i 



f- 



H 



| SUBll | 
J. ., 

| SUB12 | 
L J 



Figure 111-12. Overlay Program Before 
Automatic Promotion of 
Common Areas 



Figures 111-12 and 111-13 show an 
overlay program as it appears before and 
after the automatic promotion of COMMON 
areas. The position of a promoted COMMON 
area within the segment to which it is 
promoted is unpredictable. 



If INSERT statements are used to 
structure the overlay program, a blank 
COMMON area should appear physically in the 
input stream in the segment to which it 
belongs. A named COMMON area should either 
appear physically in the segment to which 
it belongs or should be placed there with 
an INSERT statement. 



COMMON areas encountered in modules from 
automatic call libraries are automatically 
promoted to the root segment. If such 
COMMON areas are named, they may be 
positioned by the use of an INSERT 
statement. 



Named COMMON areas in BLOCK DATA 
subprograms must be exactly as large as any 
identically named COMMON areas in FORTRAN 
programs that are to be link edited with 
the BLOCK DATA subprograms. 



r x 1 

| SUB3 | 
j. ., 

| SUB4 | 

f- 1 

| COMMONB | 
L T J 

I 

I 

r x 1 

| SUB8 | 
f. .| 

I 
.J 



MAIN 



SUB1 



h 



| SUB2 | 

f— ^ 

I COMMONA I 
L T — J 

I 
J. 



r A 1 

| SUB10 | 
L J 



SUB9 



r A — i 

| SUBll | 

i- ^ 

| SUB12 | 
L j 



I 

r x 1 

| SUB5 | 

i- ^ 

j SUB6 j 

\ ^ 

| SUB7 j 
L J 



Figure 111-13. Overlay Program After 
Automatic Promotion of 
Common Areas 



Linkage Editor Overlay Feature 145 



CONSTRUCTION OF THE OVERLAY PROGRAM 



The programmer communicates his overlay 
strategy to the operating system in two 
ways: through the use of special 
processing options which he specifies in 
the PARM parameter of the EXEC statement 
that calls the linkage editor, and through 
the use of linkage editor control 
statements. The general functions of these 
options and statements are described in the 
section "Linkage Editor and Loader. " Those 
which are of particular interest to the 
programmer constructing an overlay program 
are discussed immediately below. 



may be used to indicate overlay of segments 
2 and 6 in Figure III-8: 

OVERLAY ALPHA 

OVERLAY statements are placed directly 
before the object decks of the first 
program unit of the new segment, before an 
INSERT statement specifying the program 
units to be placed in the segment, or 
before an INCLUDE statement specifying the 
program units to be placed in the segment. 
Assuming that object decks were available, 
the input deck to the linkage editor for 
the program in Figures III- 8 and III- 9 
could be arranged as follows: 



LINKAGE EDITOR CONTROL STATEMENTS 



Once the programmer has designed an overlay 
tree structure for this program, he places 
the program in that structure by indicating 
to the linkage editor the relative 
positions of the segments that make up the 
tree. The control statements which 
accomplish this are placed in the input 
stream following the //SYSLIN DD statement, 
or after the //LKED. SYSLIN DD statement if 
a cataloged procedure is used. 



The most important control statements 
for implementing an overlay program are the 
OVERLAY, INSERT, INCLUDE, and ENTRY 
statements. The OVERLAY statement 
indicates the beginning of an overlay 
segment. The INSERT statement is used to 
rearrange the sequence of object modules in 
the resulting load module(s). The INCLUDE 
statement is used to incorporate input from 
secondary sources into the load module. 
The ENTRY statement specified the first 
instruction to be executed. 



Object deck for 



OVERLAY ALPHA 
Object deck for 



OVERLAY BETA 
Object deck for 



OVERLAY BETA 
Object deck for 



OVERLAY BETA 
Object deck for 



OVERLAY ALPHA 
Object deck for 

ENTRY MAIN 



MAIN 
SUB1 
SUB2 



SUB3 
SUBU 



SUB5 
SUB6 
SUB7 



SUB8 
SUB9 



SUB10 



SUB11 
SUB12 



INSERT Statement 



OVERLAY Statement 

The OVERLAY statement indicates the 
beginning of an overlay segment. Its 
format is: 

r t 1 

| Operation | Operand | 
V 4 1 

| OVERLAY | name | 

l x J 



where name indicates the beginning of the 
segment, that is, the symbolic name of the 
relative origin. The following statement 



There are many instances in which it is 
inconvenient or impossible for the user to 
position object decks physically in the 
input stream. Library routines, normally 
placed in the root segment, and routines 
compiled in an earlier step in the same job 
are examples of program units for which the 
object decks are not available for 
positioning at the time the job is set up. 

The INSERT statement is used to position 
such control sections in an overlay 
structure. A control section, or CSECT, is 
the operating system designation for the 
smallest separately relocatable unit of a 
program. Examples of FORTRAN control 
sections are main programs, subprograms, 
and blank or named COMMON blocks. 



146 



The format of the INSERT statement is 



r T 1 

| Operation | Operand | 

j. 4. 4 

j INSERT I csect-name [, csect-name. . . ] | 
l 1 J 



subprogram is required in more than one 
path, it must be either inserted in the 
root segment or renamed before being used 
with an INSERT statement. 



where csect-name indicates the name(s) of 
the control section(s) to be positioned. 

The INSERT statement is placed in the 
input sequence directly following the 
OVERLAY statement that specifies the 
segment origin in which the control section 
is to be positioned. If the control 
section is to be positioned in the root 
segment, the INSERT statement is placed 
before the first OVERLAY statement. 

Using INSERT statements and a FORTRAN 
source deck, the overlay structure 
specified in Figures III-8 and III-9 could 
be implemented as follows: 



INCLUDE Statement 



The INCLUDE statement is described in the 
section "Linkage Editor and Loader. " When 
used in an overlay program, the INCLUDE 
statement is generally placed in the input 
stream in the position where th 
to be included is required. 



/-.~-; -. i 



na ten 



It is possible to manipulate the control 
sections that were added by an INCLUDE 
statement through the use of the INSERT 
statement. Assume that the control 
sections of the overlay program from the 
previous examples resided in libraries as 
follows : 



Input to the compiler: 

r 

I FORTRAN source deck containing units 
I MAIN through SUB12 

L 

Input to the linkage editor: 

r 

ENTRY MAIN 

INSERT MAIN, SUB1,SUB2 



OVERLAY ALPHA 
INSERT SUB3,SUB4 



OVERLAY BETA 

INSERT SUB5, SUB6, SUB7 



OVERLAY BETA 
INSERT SUB8,SUB9 



OVERLAY BETA 
INSERT SUB10 



OVERLAY ALPHA 
INSERT SUB11,SUB12 



If INSERT statements are used more than 
once in the same program for a control 
section of the same name, the CSECT will be 
positioned in the segment specified by the 
first occurrence of the CSECT name in the 
input stream. Any additional INSERT 
statements referring to the CSECT will be 
ignored, and, at execution time, all 
references to the CSECT will resolve to the 
first one positioned. Thus, if a 



r 1 

I LIBA J 
f. T 4 

I BOOK1 I BOOK2 | 
|. + ., 

I MAIN I SUB3 I 
I SUB1 I SUB4 I 
I SUB2 I j 

L 1 J 



LIBB I 



SUB5 

SUB6 

SUB7 

SUB 8 

SUB9 

SUB10 

SUB11 

SUB12 



H 



where LIBA is a partitioned data set with 
members BOOK1 and BOOK2 and LIBB is a 
sequential data set. 



Then the overlay structure could be 
implemented by the use of the following 
control statements: 



ENTRY MAIN 

INCLUDE LIBA(BOOKl) 
INCLUDE LIBB 
OVERLAY ALPHA 
j. ., 

INCLUDE LIBA(BOOK2) 
OVERLAY BETA 
INSERT SUB5,SUB6,SUB7 
OVERLAY BETA 
INSERT SUB8,SUB9 
OVERLAY BETA 
INSERT SUB10 
OVERLAY ALPHA 
INSERT SUB11, SUB12 



Linkage Editor Overlay Feature 147 



ENTRY Statement 



The ENTRY statement specifies the first 
instruction of the program to be executed. 
Its format is: 

r t t 

| Operation | Operand | 
V + -I 

| ENTRY | external- name | 
l x J 

where external-name indicates the name of 
an instruction in the root segment. 
Usually it will be the name MAIN. 

The ENTRY statement may be placed 
before, between, or after the program units 
or other control statements in the input 
stream. An ENTRY statement is necessary in 
all overlay programs because, after linkage 
editor processing, the first part of the 
root segment contains special overlay 
control information rather than executable 
code. See the previous examples of overlay 
implementation for the use and placement of 
the ENTRY statement. 



XREF indicates that the linkage editor 
is to produce a cross-reference table of 
the output module. The cross-reference 
table includes a module map and a list of 
all address constants that refer to other 
control sections. Since the 
cross-reference table includes a module 
map, XREF may be substituted for MA.P. 

XCAL indicates that a valid exclusive 
call is not to be considered an error, and 
that the load module is to be marked 
executable even though improper branches 
were made between control sections. 

LET indicates that any exclusive call 
(valid or invalid) is accepted. The output 
module will be marked executable even 
though certain error or abnormal conditions 
were found during link editing. At 
execution time, a valid exclusive call may 
or may not be executed correctly. An 
invalid call will usually cause 
unpredictable results; the reguested 
segment will not be loaded. 



OVERLAY EXAMPLE 



LINKAGE EDITOR OVERLAY OPTIONS 



In addition to the necessary linkage editor 
control statements, the user implementing 
an overlay structure must provide certain 
information to the operating system by 
means of the PARM parameter of the EXEC 
statement that calls the linkage editor. 

Linkage editor options are described in 
the section "Linkage Editor and Loader. " 
Those options which are of special interest 
to the user of the overlay feature are 
discussed in the following paragraphs. 

OVLY indicates that the load module 
produced will be an overlay structure, as 
directed by subseguent linkage editor 
control statements. OVLY must be specified 
for all overlay processing. 

LIST indicates that linkage editor 
control statements are to be listed in card 
image format on the system output data set, 
SYSPRINT. 

MAP indicates that the linkage editor is 
to produce a map of the output module. The 
map of the output module of an overlay 
structure shows the control sections 
grouped by segment. Within each segment, 
the control sections are listed in 
ascending order according to their assigned 
origins. The number of the segment in 
which each appears is also printed. 



Assume that the program suggested by Figure 
III-8 consists of a main program and twelve 
subroutines. The sole function of the main 
program is to call the subroutines, and 
each subroutine prints the message "IN 
SUBx", where x is a number identifying the 
subroutine. 

Figure 111-14 illustrates the input and 
Figure 111-15 the output of the program. 

Figure 111-14 shows the program in card 
deck form, as it might be submitted for 
execution. The EXEC statement specifies 
the cataloged procedure FORTXCLG, to 
process three job steps to compile, link 
edit, and execute. The EXEC statement also 
specifies the linkage editor options OVLY, 
XREF, and LIST. 

Input to the compile step consists of 
the statements in the main program unit and 
in the subroutines. 

Input to the link edit step consists of 
INSERT, OVERLAY, and ENTRY statements, 
which define the overlay structure of the 
program. 

There is no input to the load module 
step; however, output from the step is 
directed to the printer, as defined by the 
DD statement //GO.FT06F001. 

Output from the compile job step is 
shown in Figure 111-15. Note that each 
program unit is compiled separately. The 



148 



FORTRAN IV (H Extended) compiler recognizes 
the FORTRAN END statement as the last 
statement in a unit. 



the following statement defines one overlay 
segment : 



shown in Figure 111-16. The LIST option 
causes the linkage editor control 
statements to be listed (labeled A). The 
XREF option causes a cross reference table 
to be printed for each overlay segment. 
Each overlay segment consists of the 
FORTRAN program units specified in an 
INSERT statement together with any modules 
called by the linkage editor. For example, 



INSjckt MAi.N, bUtJl, bUB^ 

The overlay segments are labeled B through 
G. The OVLY option causes no printed 
output. 

Output from the load module execution 
job step is shown in Figure 111-17. The 
messages generated by the subroutines are 
labeled H. 



Linkage Editor Overlay Feature 149 



// EXEC FORTXCLG,PARM.LKED= 
//FORT.SYSIN DD " INPUT TO COMP 

CALL SUB1 

CALL SUB2 

CALL SUB3 

CALL SUB^ 

CALL SUB5 

CALL SUB6 

CALL SUB7 

CALL SUB8 

CALL SUB9 

CALL SUB10 

CALL SUB11 

CALL SUB12 

STOP 

END 

SUBROUTINE SUB1 

DIMENSION A(100, 10) 
15 FORMAT C1H0,8HIN SU 

WRITE (6,15) 

RETURN 

END 

SUBROUTINE SUB2 

DIMENSION AC100, 10) 
15 FORMAT (1H0,8HIN SU 

WRITE (6,15) 

RETURN 

END 

SUBROUTINE SUB3 

DIMENSION A(100,10) 
15 FORMAT (1H0,8HIN SU 

WRITE (6,15) 

RETURN 

END 

SUBROUTINE SUB4 

DIMENSION A(100,10) 
15 FORMAT (1H0,8HIN SU 

WRITE (6,15) 

RETURN 

END 

SUBROUTINE SUB5 

DIMENSION A(100, 10) 
15 FORMAT (1H0,8HIN SU 

WRITE (6,15) 

RETURN 

END 

SUBROUTINE SUB6 

DIMENSION A(100,10) 
15 FORMAT (1H0,8HIN SU 

WRITE (6,15) 

RETURN 

END 



*OVLY,XREF,LIST' 
ILE JOB STEP 




SUBROUT 

DIMENSI 

FORMAT 

WRITE ( 

RETURN 

END 

SUBROUT 

DIMENSI 

FORMAT 

WRITE ( 

RETURN 

END 

SUBROUT 

DIMENSI 

FORMAT 

WRITE ( 

RETURN 

END 

SUBROUT 

DIMENSI 

FORMAT 

WRITE ( 

RETURN 

END 

SUBROUT 

DIMENSI 

FORMAT 

WRITE ( 

RETURN 

END 

SUBROUT 

DIMENSI 

FORMAT 

WRITE ( 

RETURN 

END 



INE SUB7 

ON A(100,10) 

(1H0,8HIN SUB7 ) 

6,15) 



INE SUB8 

ON A(100,10) 

(1H0,8HIN SUB 8 ) 

6,15) 



INE SUB9 

ON A(100,10) 

(1H0,8HIN SUB 9 ) 

6,15) 



INE SUB10 
ON<+A(100,10) 
(1H0,8HIN SUB 10) 
6,15) 



INE SUB11 
ON A(100,10) 
(1H0,8HIN SUB 11) 
6,15) 



INE SUB12 
ON A(100,10) 
(1H0,8HIN SUB 12) 
6,15) 



ED.SYSIN DD " INPUT TO LINK EDIT JOB STEP 

ERT MAIN,SUB1,SUB2 

RLAY ALPHA 

ERT SUB3,SUBit 

RLAY BETA 

ERT SUB5,SUB6,SUB7 

RLAY BETA 

ERT SUB8,SUB9 

RLAY BETA 

ERT SUB10 

RLAY ALPHA 

ERT SUB11,SUB12 

RY MAIN 

.FT06F001 DD SYSOUT=A OUTPUT FROM LOAD MODULE JOB STEP 



Figure III- 14. Linkage Editor Overlay Input 



150 



REQUESTED OPTIONS: NODECK, NOLI ST ,OPT=0 

CPTIONS IN EFFECT: NAME( MA IN ) , NOOPTI MI ZE , L IN ECOUNT (60 I ,S IZ E( MAX ) , AUTODBL ( NON E) , 

SOURCE, EBCDIC, NOL 1ST, NODECK, OB J ECT, NOMAP, NOFORMAT, NOGOSTMT, NOXREF, NOALC, NOANSF, FLAG (I ) 

ISN 0002 CALL SUB1 

ISN 0C03 CALL SUB2 

ISN 0004 CALL SUB3 

ISN 0006 CALL SUB5 

ISN 0007 CALL SUB6 

ISN 0008 CALL SUB7 

ISN 0009 CALL SUB8 

ISN 0010 CALL SUB9 

ISN 0C11 CALL SUB10 

ISN 0012 CALL SUB11 

ISN 0013 CALL SUB12 

ISN 0014 STOP 

ISN 0015 END 

♦OPTIONS IN EFFECT*NAME( MAIN ), NOOPT IMI ZE , L I NECOUNT (6C ), SIZ E( MAX) , AUTODBL ( NONE ) , 

*0 PT 1 3 NS IN EFr cCT*o OURc t_» uS^D iu » t>luL ui » NuDEuK fOBJcu i t imQhmP » NuruRrmi * iiuouj i ■•! i ? Nu XR i_r yt^JGALC * NuANoF ? rL ho\I i 

*CT»TTCTTrf* C OMD r C CTHTCMCMTC _ I /, OD nr D A U C T 7 C — QIO CKDOOnrDAU KIAMC = MATM 

♦STATISTICS* NO DIAGNOSTICS GENERATED 

****** eno OF COMPILATION ****** 105K BYTES OF CORE NOT USED 

REQUESTED OPTIONS: NODECK, NOL I ST, OPT=0 

CPTIONS IN EFFECT: NAME! MA IN ), NOOPTI MI ZE , L I NEC OUNT (60 ), SI Z E( MAX) , AUTODBL ( NONE) , 

SOURCE, EBCDIC, NOL IS T, NODECK, OBJ ECT, NOMAP, NOFORMAT .NOGOSTMT, NOXREF ,NOALC , NOANSF, FL AG ( I ) 

ISN 000 2 SUBROUTINE SUB1 

ISN 0003 DIMENSION A(100,1C) 

ISN 0004 15 FORMAT (1H0,8HIN SUB1 ) 
ISN 0005 WRITE (6,15) 

ISN 0006 RETURN 

ISN 0007 END 

♦OPTIONS IN EFFECT*NAME( MA IN ), NOOPTI MI ZE ,L I NECOUNT (60 ) ,SIZ E( MAX ), AUTODBL ( NONE ) , 

♦OPTIONS IN EP FECT*S OU RC E, EBCDIC, NOL 1ST, NODECK, OBJ ECT, NOMAP, NOFORMAT, NOGOSTMT, NOXREF, NOALC, NOANSF, FLAG (I ) 

♦STATISTICS* SOURCE STATEMENTS = 6, PROGRAM SIZE = 218, SUBPROGRAM NAME = SUB1 

♦STATISTICS* NO DIAGNOSTICS GENERATED 

****** END op COMPILATION ****** 10 5K BYTES OF CORE NOT USED 



REQUESTED OPTIONS: NODEC K, NOLI ST , OPT=0 

CPTIONS IN EFFECT: NAME( MA IN ), NOOPTI MI ZE , L I NECOUNT (60 ), S IZ E( MAX ), AUTODBL ( NON E) , 

SOURCE, EBCDIC, NOL I ST, NODECK, OB J ECT, NO MAP, NOFORMAT, NOGOSTMT, NOXREF, NOALC, NOANSF, FLAG (I ) 

ISN 0002 SUBROUTINE SUB12 

ISN 0003 DIMENSION A(100,10) 

ISN CC04 15 FORMAT (1H0,8HIN SUB12) 

ISN 0005 WRITE (6,15) 

ISN 0006 RETURN 

ISN 0007 END 

♦OPTIONS IN EFFECT*NAME( MA IN ), NOOPTI MI ZE , LI NECOUNT ( 60 ) ,S I ZE ( MAX) , AUTODBL ( NON EJ , 

♦OPTIONS IN EFFECT*SOURCE, EBCDIC, NOL 1ST, NODECK, OB J ECT, NO MAP, NOFORMAT, NOGOSTMT, NOXREF, NOALC, NOANSF, FLAG (I ) 

♦STATISTICS* SOURCE STATEMENTS = 6, PROGRAM SIZE = 218, SUBPROGRAM NAME = SUB12 

♦STATISTICS^ NO DIAGNOSTICS GENERATED 

****** eno of COMPILATION *♦♦♦♦♦ 105K BYTES OF CORE NOT USED 

♦STATISTICS^ NO DIAGNOSTICS THIS STEP 



Figure 111-15. Linkage Editor Overlay Output — Compile Job Step 



Linkage Editor Overlay Feature 151 



F88-LEVEL LINKAGE EDITOR OPTIONS SPECIFIED OvLY , XRE F , L I ST 
VARIABLE OPTIONS USED - SI ZE=< 92 160, 81 92 )- 

IEWOOOO INSERT M AI N, SUB1 , SUB2 

IEWOOOO OVERLAY ALPHA 

IEWOOOO INSERT SUB3.SUB4 

' IEWOOOO OVERLAY BETA 

^IEWOOOO INSERT SUB5, SUB6 , SUB7 

MIEWOOOO OVERLAY BETA 

W IEWOOOO INSERT SL)B8,SUB9 

IEWOOOO OVERLAY BETA 

IEWOOOO INSERT SUB10 

IEWOOOO OVERLAY ALPHA 

IEWOOOO INSERT SUB11.SUB12 

IEWOOOO ENTRY MAIN 

****MAIN DOES NOT EXIST BUT HAS BEEN ADDED TO DATA SET 



DEFAULT OPTIONISI USED 



CONTROL SECTION 



ORIGIN LENGTH SEG. NO. 



SSEGTAB 


00 


30 1 


MAIN 


30 


13E 1 


SUB1 


170 


DA 1 


SUB2 


250 


DA 1 


IHOECOMH* 


330 


DC4 1 


IH0C0MH2* 


10F8 


975 1 


IHOFCVTH* 


1A70 


A07 1 


IHOEFNTH* 


2478 


7C8 1 


IHOEFIOS* 


2C40 


10F0 1 


IH0FI0S2* 


3D30 


5 AC 1 


IHOUOPT * 


42 EO 


318 1 


IHOFCONI* 


45F8 


2FD 1 


IHOFCONO* 


48F8 


558 1 


IHOERRM * 


4E50 


5 EC 1 


IHOUATBL* 


5440 


2 08 1 


IHOFTEN * 


5648 


198 1 


IHOETRCH* 


57E0 


2A6 1 


$ENTAB 


5A88 


84 1 



© 



CROSS REFERENCE TABLE 



LOCATION 



NAME LOCATION 



IBCOM# 


35C 


FDIOCS# 


418 


INTSWTCH 


10E0 






SEQDASD 


1462 














ADCON# 


1A70 


FCVAOUTP 


1B1A 


FCVLOUTP 


1BAA 


FCVZOUTP 


1D06 


FCVIOUTP 


20AA 


FCVEOUTP 


219C 


FCVCOUTP 


219C 


INT6SWCH 


23F8 


ARITH# 


2478 


ADJSWTCH 


29D8 










FIOCS# 


2C40 


FIOCSBEP 


2C46 










FQCONI* 


45F8 














FQCONO* 


48F8 














ERRMON 


4E50 


IHOERRE 


4E68 










FTEN# 


5648 














IHOTRCH 


57E0 


ERRTRA 


57E8 











LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 



A8 

30 

B8 

CO 

C8 

DO 

D8 

2E8 

470 

FE4 

100C 

FF4 

FFC 

1004 

10E4 

F98 

F9C 

FA4 

1228 

18CD 

18ED 

2264 

22BC 

2 A3 8 

29D0 

2A3C 

2DA8 

2DA4 

3ACC 

3AF8 

4884 

542C 

5434 

5 96 8 

5974 



SUB1 

SUB3 

SUB5 

SUB7 

SUB9 

SUB11 

IBCOM# 

IBCOM# 

IH0C0MH2 

FIOCS# 

ADJSWTCH 

FCVEOUTP 

FCVIOUTP 

FCVAOUTP 

IHOASYNC 

IHOERRE 

IH0C0MH2 

IH0C0MH2 

IHOECOMH 

IHOECOMH 

IHOECOMH 

IHOERRM 

FQCONI# 

INTSWTCH 

IHOUOPT 

FIOCS# 

IHOASYNC 

IH0FI0S2 

IBC0M# 

IH0FI0S2 

FTEN# 

IHOUOPT 

IHOTRCH 

IBCOM# 

FIOCSBEP 



SUB1 

SUB3 

SUB5 

SUB7 

SUB9 

SUB11 

IHOECOMH 

IHOECOMH 

IH0C0MH2 

IHOEFIOS 

IHOEFNTH 

IHOFCVTH 

IHOFCVTH 

IHOFCVTH 
$UNRESOLVED(W) 

IHOERRM 

IH0C0MH2 

IH0C0MH2 

IHOECOMH 

IHOECOMH 

IHOECOMH 

IHOERRM 

IHOFCONI 

IHOECOMH 

IHOUOPT 

IHOEFIOS 
$UNRESOLVED(W) 

IH0FI0S2 

IHOECOMH 

IH0FI0S2 

IHOFTEN 

IHOUOPT 

IHOETRCH 

IHOECOMH 

IHOEFIOS 



AC 

B4 

BC 

C4 

CC 

D4 

208 

418 

FEC 

FFO 

FCO 

FF8 

1000 

1008 

F44 

FC8 

FAO 

FA8 

12D8 

18DD 

2268 

22B8 

2A34 

29D4 

2A40 

2B40 

2DA0 

3AC0 

3AE1 

3D29 

4CF4 

5430 

5438 

596C 



SUB2 


SUB2 


1 


SUB4 


SUB4 


2 


SUB6 


SUB6 


3 


SUB8 


SUB8 


4 


SUB10 


SUB10 


5 


SUB 12 


SUB12 


6 


IBCOM# 


IHOECOMH 


1 


SEQDASD 


IH0C0MH2 


1 


ADCON# 


IHOFCVTH 


1 


ARITH# 


IHOEFNTH 


1 


IHOUOPT 


IHOUOPT 


1 


FCVLOUTP 


IHOFCVTH 


1 


FCVCOUTP 


IHOFCVTH 


1 


FCVZOUTP 


IHOFCVTH 


1 


IHOERRM 


IHOERRM 


1 


IH0C0MH2 


IH0C0MH2 


1 


IH0C0MH2 


IH0COMH2 


1 


IH0C0MH2 


IH0C0MH2 


1 


IHOECOMH 


IHOECOMH 


1 


IHOECOMH 


IHOECOMH 


1 


IBCOM# 


IHOECOMH 


1 


FQCONO* 


IHOFCONO 


1 


IBCOM* 


IHOECOMH 


1 


INT6SWCH 


IHOFCVTH 


1 


ADCON# 


IHOFCVTH 


1 


IHOERRM 


IHOERRM 


1 


IHOERRM 


IHOERRM 


1 


IHOUATBL 


IHOUATBL 


1 


IH0FI0S2 


IH0FIOS2 


1 


IH0FI0S2 


IH0FI0S2 


1 


FTEN# 


IHOFTEN 


1 


IBCOM* 


IHOECOMH 


1 


FIOCSBEP 


IHOEFIOS 


1 


ADCON# 


IHOFCVTH 


1 



Figure 111-16. Link Edit Overlay Output — Link Edit Job Step 



152 



CONTROL SECTION ENTRY 

NAME ORIGIN LENGTH SEG. NO. NAME 



SUB3 
SUB4 



5810 
5BF0 



DA 
DA 



© 



LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 
5BA8 I BCOM# IHOECOMH 1 



LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 
5C88 IBCOM# IHOECOMH 1 



CONTROL 


SECTION 








ENTRY 
















NAME 


ORIGIN 


LENGTH 


SEG. 


NO. 


NAME 


LOCATION 


NAME 


LOCATION 


NAME 


LOCATION 


NAME 


LOCATION 


SUB5 
SUB6 
SUB7 


5CD0 
5DB0 
5E90 


DA 
DA 
DA 


3 
3 
3 





















LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 



5068 




IBCOM# 




IHOECOMH 


1 


5F28 




IBCOM# 




IHOECOMH 


1 


CONTROL 


SECTION 






ENTRY 




NAMF 


ORIGIN 


1 FNir,TH 


SEG, NQ, 


MAU.C 


i_nr at t 


SUB8 


5CD0 


DA 


h 






SUB9 


5DB0 


DA 


4 







LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 
5E48 IBCOM# IHOECOMH 1 



LULAI 1UN 



LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 
5068 IBCOM# IHOECOMH 1 



CONTROL SECTION ENTRY 

NAME ORIGIN LENGTH SEG. NO. NAME 
ISUB10 5CDC DA 5 



LOCATION 



LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 
5E48 IBCOM# IHOECOMH 1 



NAME LOCATION 



LOCATION 



© 



LOCATION 


REFERS 


TO SYMBOL IN CONTROL SECTION 


SEG. NO 


5068 




IBCOM# IHOECOMH 


1 


CONTROL 


SECTION 


ENTRY 




NAME 


ORIGIN 


LENGTH SEG. NO. NAME 


LOCATION 


SUB11 


5B1C 


DA 6 




SUB12 


5BFC 


DA 6 





LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 



LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 
5BA8 IBCOM# THOFCOMH 1 



ENTRY ADDRESS 


30 


TOTAL LENGTH 


5F70 


Figure 111-16. 


Lin} 


IN SUBl 




IN SUB2 




IN SUB3 




IN SUB4 




IN SUB5 




IN SUB6 




IN SUB7 




IN SUB8 




IN SUB 9 




IN SUB10 




IN SUBU 




IN SUB12 




Figure 111-17. 


Lin] 



LOCATION REFERS TO SYMBOL IN CONTROL SECTION SEG. NO. 
^r.an ip.r. dm a innFr.nMm \ 



-16. Link Edit Overlay Output — Link Edit Job Step (Part 2 of 2) 



17. Linkage Editor Overlay Output — -Load Module Execution Job Step 

Linkage Editor Overlay Feature 153 



EXTENDED ERROR HANDLING FACILITY 



The extended error handling facility 
provides the FORTRAN programmer with 
greater control over load module errors. 
This facility is specified at program 
installation time through the parameter 
OPTERR= INCLUDE in the FORTLIB macro 
instruction. 



• The maximum number of times each 
message may be printed 

• Whether or not the traceback map is to 
be printed with the message 

• Whether or not a user-written 
error-exit routine is to be called 



When a program error occurs, the user is 
given: 

• Messages more informative than those 
issued with standard diagnostic 
facilities 

• The ability to continue execution after 
the error 

• Either standard FORTRAN corrective 
action with continued execution or, 
optionally, user-specified corrective 
action 



The action that takes place is governed by 
information stored in an area of main 
storage called the option table. (A 
permanent copy of the option table is 
maintained in the FORTRAN library. ) 



FUNCTIONAL CHARACTERISTICS 



When an error is detected, the FORTRAN 
error monitor (ERRMON) receives control. 



When an error occurs with extended error 
handling in effect, a short message text is 
printed along with an error identification 
number. The data in error (or some other 
associated information) is printed as part 
of the message text. A summary error 
count, printed when a job is completed, 
informs the user how many times each error 
occurred. For a complete listing of 
compiler and library messages, see the 
publication OS FORTRAN IV (H Extended) 
Compiler and Library (Mod II) Messages , 
Order No. SC28-6865. 

A traceback map, tracing the subroutine 
flow back to the main program, is printed 
after each error occurrence; execution then 
continues. (If the extended error handling 
facility is not specified, a traceback map 
is printed only for errors causing program 
termination and for error IH0218I if the 
ERR= option has been specified in a READ 
statement. ) 

For each error condition detected, the 
user has both dynamic and default control 
over: 

• The number of times the error is 
allowed to occur before program 
termination 



The error monitor prints the necessary 
diagnostic and informative messages and 
then takes one of the following actions: 

• Terminates the job 

• Returns control to the calling routine, 
which takes a standard corrective 
action and then continues execution 

• Calls a user-written closed subroutine 
to correct the data in error and then 
returns to the routine that detected 
the error, which then continues 
execution 

The actions of the error monitor are 
controlled by settings in the option table. 
The option table consists of a doubleword 
preface, followed by a doubleword entry for 
each error condition. (If the extended 
error handling facility is not specified, 
the option table is reduced to the preface 
alone. ) IBM provides a standard set of 97 
entries; the programmer can provide 
additional entries at program installation 
time. Table III- 3 shows the values for 
each error condition. If an option 
recorded in a table entry does not apply to 
a particular error condition, it is shown 
as not applicable (NA) . 



154 



Table III-3. Option Table Default Values 



Option Bits 







r t 




Number of 


Number of | 




[Print 




Standard 




Error 


Errors 


Messages! 


[Modifiable 


Buffer 


Traceback 


[ Corrective 


User 


Code 


Allowed 


Allowed | Print Control 


Entry 


Content 


Allowed 


Action 


Exit 


4 4 4 4 4 4 4 4 


205 


1 


1 | NA 


No 


No 


NO 


No 


[ NO 


206 


10 


5 j NA 


Yes 


NA 


Yes 


Yes 


NO 


207 


10 


5 ! NA 


Yes 


NA 


J. CO 


Yes 


NO 


208 


Unlimited 


5 j NA 


Yes 


NA 


Yes 


Yes 


NO 


209 


10 


5 j NA 


Yes 


NA 


Yes 


Yes 


No 1 


210 


Unlimited 


10 j NA 


Yes 


NA 


Yes 


Yes 1 


No 


211 


10 


5 j NA 


Yes 


NA 


Yes 


Yes 


No 


212 


10 


5 j NO 2 


Yes 


Yes 


Yes 


Yes 


NO 


213 


10 


5 j NA 




NA 


Yes 


Yes 


NO 


214 


10 


5 | NA 


Yes 


NA 


Yes 


Yes 


NO 


215 


Unlimited 


5 | NA 


Yes 


Yes 


Yes 


Yes 


NO 


216 


10 


5 | NA 


Yes 


NA 


Yes 


Yes 3 


NO 


217 


1** 


1 j NA 


Yes 


NA 


Yes 


Yes 


NO 


218 


10 5 


5 j NA 


Yes 


Yes 5 


Yes 


Yes 


NO 


219 


10« 


5 | NA 


Yes 


NA 


Yes 


Yes 


NO 


220 


10 


5 j NA 


Yes 


NA 


Yes 


Yes 


No 


221 


10 


5 | NA 


Yes 


Yes 


Yes 


Yes 


NO 


222 


10 


5 j NA 


Yes 


Yes 


Yes 


Yes 


NO 


223 


10 


5 | NA 


Yes 


Yes 


Yes 


Yes 


NO 


224 


10 


5 | NA 


Yes 


Yes 


Yes 


Yes 


NO 


225 


10 


5 | NA 


Yes 


Yes 


Yes 


Yes 


NO 


226 


10 


5 j NA 


Yes 


NA 


Yes 


Yes 


NO 


227 


10 


5 | NA 


Yes 


NA 


Yes 


Yes 


NO 


229 


10 


5 | NA 


Yes 


NA 


Yes 


Yes | 


NO 


230 


1 


1 | NA 


NO 


NA 


Yes 


No 


NO 


231 


10 


5 | NA 


Yes 


NA 


Yes 


Yes | 


NO 


232 


10 


5 | NA 


Yes 


NA 


Yes 


Yes 


NO 


233- 


10 


5 | NA 


Yes 


NA 


Yes 


Yes 


NO 


237 
















240 


1 


1 | NA 


No 


NA 


Yes 


No 


NO 


241- 


10 


5 j NA 


Yes 


NA 


Yes 


Yes 


NO 


285 
















286 


10 


5 | NA 


Yes 


NA 


Yes 


Yes 


No 


287 


10 


5 I NA 


Yes 


NA 


Yes 


Yes 


NO 


288 


10 


5 j NA 


Yes 


NA 


Yes 


Yes | 


NO 


289- 


10 


5 | NA 


Yes 


NA 


Yes 


Yes 


NO 


301 































^-No corrective action is taken except to continue execution. For boundary alignment, 
the corrective action is part of the support for misalignment. 

2 If a print control character is not supplied, the overflow line is not shifted to 
incorporate the print control character. Thus, if the device is tape, the data is 
intact, but if the device is a printer, the first character of the overflow line is 
not printed but is treated instead as the print control. Unless the user has planned 
the overflow, the first character would be random and thus the overflow print line 
control can be any of the possible ones. It is suggested that when the device is a 
printer, the option be changed to provide single spacing. 

3 Corrective action consists of return to execution for SLITE. 

"It is not considered an error if the END parameter is present in a READ statement. No 
message or traceback is printed and the error count is not altered. 

5 For an input/output error, the buffer may have been partially filled or not filled at 
all when the error was detected. Thus, the buffer contents could be blank when 
printed. When an ERR parameter is specified in a READ statement, it is honored even 
though the error occurrence is greater than the amount allowed. 

6 The count field does not necessarily mean that up to 10 missing DD cards will be 
detected in a single debugging run, since a single WRITE performed in a loop could 
cause 10 occurrences of the message for the same missing DD card. 



Extended Error Handling Facility 155 



The field that is defined as the 
user-exit address also serves as a means of 
specifying standard corrective action. 
When the table entry contains an address, 
the user exit is specified; when it 
contains the integer 1, standard correction 
is specified. It is not possible at 
program installation time to create an 
option table entry with the user-exit 
address specified. The user exit must be 
specified by altering the option table at 
execution time. To specify that no 
corrective action, either standard or 
user-written, is to be taken, the table 
entry must specify that only one error is 
to be allowed before termination of 
execution. 

To make changes to the option table 
dynamically at load module execution time, 
the programmer calls one of four 
subroutines; these subroutines are 
summarized below. 



SUBPROGRAMS FOR THE EXTENDED ERROR HANDLING 
FACILITY 



an option table entry to be copied into an 
8-byte storage area accessible to the 
FORTRAN programmer. CALL ERRSAV has the 
format: 



CALL ERRSAV (ierno, tabent) 

where : 

ierno 

is the error number to be referenced 
in the option table. Should any 
number not within the range of the 
option table be used, an error message 
will be printed. 

tabent 

is the name of an 8-byte storage area 
where the option table entry is to be 
stored. 

An example of CALL ERRSAV is : 

CALL ERRSAV (213,ALTERX) 

The example states that error number 213 
is to be stored in the area named ALTERX. 



IBM provides four subroutines for use in 
extended error handling: ERRSAV, ERRSTR, 
ERRSET, and ERRTRA. These subroutines 
allow access to the option table to alter 
it dynamically. 

Certain option table entries may be 
protected against alteration when the 
option table is set up. If a reguest is 
made by means of CALL ERRSTR or CALL ERRSET 
to alter such an entry, the reguest is 
ignored. See Table III-3 for those 
IBM-supplied option table entries that 
cannot be altered. 

Changes made dynamically are in effect 
for the duration of the program that made 
the change. Only the current copy of the 
option table in main storage is affected; 
the copy in the FORTRAN library remains 
unchanged. All passed parameters, unless 
otherwise indicated, are 4-byte (fullword) 
integers. 



ERRSAV Subroutine 



The CALL ERRSAV statement is used to modify 
an entry temporarily. The statement causes 



ERRSTR Subroutine 

To store an entry in the option table, the 
following statement is used: 

CALL ERRSTR (ierno, tabent) 

where : 

ierno 

is the error number for which the 
entry is to be stored in the option 
table. Should any number not within 
the range of the option table be used, 
an error message will be printed. 

tabent 

is the name of an 8-byte storage area 
containing the table entry data. 

An example of CALL ERRSTR is: 

CALL ERRSTR (213, ALTERX) 

The example states that error number 
213. Stored in ALTERX, is to be restored 
to the option table. 



156 



Table III-4. 
r t 



Corrective Action After Error Occurrence (Part 1 of 2) 

T T 



Error 
Code 


| Parameters 
| Passed to 
| User 1 


| Standard Corrective Action 

i- — - - 


j User-Supplied Corrective Action | 
L _ _ J 


205 


1 A.B.D 


[ Program Termination 


See Note 2 j 


206 


1 A, B.I 


|I=low order part of number for 
input too large. 


| User may alter I j 
| (See note 3) . | 


211 


A.B.C 


Treat format field containing C 
as end of FORMAT statement. 


! (a) If compiled FORMAT statement. put| 

hexadecimal equivalent of j 

character in C (see Note 1). j 

(b) If variable format, move EBCDIC | 

[ character into C (see Note 1). | 


212 


A.B.D 


Input: Ianore remainder of I/O 

list. 

Output: Continue by startinq 


See Note 2* J 




new output record. Supply 
carriage control character if 
required by Option Table. 




213 


A, B.D 


Ignore remainder of I/O list. 


See Note 2. | 


214 


A,B, D 


Input: Ignore remainder of I/O 


If user correction is requested, the | 




list. Ignore input/output 
request if for ASCII tape. 
Output: If unformatted write 


remainder of the I/O list is ignored, j 




initially requested, change 
record format to VS. If 
formatted write initally 
requested, ignore input/output 
request. 




215 


A, B, E 


Substitute zero for the invalid 
character. 


The character placed in E will be sub- | 
stituted for the invalid character; | 
input/output operations may not be | 
performed (see Note 1). | 


217 


A.B.D | 


Increment FORTRAN sequence 
number and read next file. 


See Note 2. | 


2182 


A, B.D.F 


Ignore remainder of I/O list. | 


See Note 2. | 


219- 
224 


A.B.D 


Ignore remainder of I/O list. 


See Note 2. | 


225 


A,B,E | 


Substitute zero for the invalid 
character. | 


The character placed in E will be sub- | 
stituted for the invalid character j 
(see Note 1). | 


226 | 


A.B.R | 


R=0 for input number too small; j 
R=16 63 -l for input number too | 
large. | 


User may alter R. J 


227 | 


A,B,D | 


Ignore remainder of I/O list. | 


See Note 2. | 


229 | 


A. B.D | 


Ignore remainder of I/O list. | 


See Note 2. | 


231 | 


A.B.D | 


Ignore remainder of I/O list. | 


See Note 2. | 



Extended Error Handling Facility 157 



Table III-4. Corrective Action After Error Occurrence (Part 2 of 2) 
r" 



-t — r 

| Parameters | 

Error | Passed toj 

Code | Use 1 j Standard Corrective Action 
+ + 

232 | A, B,D,G (Ignore remainder of I/O list. 


T - 

| User Supplied Corrective Action 
_ + 

|See Note 2. 


233 


A, B,D 




Change record number to list 
maximum allowed (32,000). 


jsee 


Note 


2. 


234- 
236 


A,B,D 




Ignore 


remainder of I/O list. 


| See 


Note 


2. 


237 


A, B,D, 


F 


Ignore 


remainder of I/O list. 


|See 


Note 


2. 


238 


A, B,D 




Ignore 


remainder of I/O list. 


|See 


Note 


2. 


286 


A, B,D 




Ignore 


Request 


jsee 


Note 


2. 


287 


A, B,D 




Ignore 


Request 


jsee 


Note 


2. 


288 


A, B,D 




Implied Wait 


|See 


Note 


2. 



J. J. J. 

1 Parameter Code 

A 

B 

C 

D 

E 

F 

G 

I 

R 



Meaning 

Address of return code field (INTEGER* 4) 

Address of error number (INTEGER* 4) 

Address of invalid format character ( LOGICAL* 1) 

Address of data set reference number (INTEGER*4) 

Address of invalid character (LOGICAL+1) 

Address of DECB 

Address of record number requested (INTEGER* 4) 

Result after conversion (INTEGER* 4) 

Result after conversion (REAL* 4) 



2 If error condition 218 (input/output error detected) occurs while error messages are 
being written on the object error data set # the message is written on the console and 
the job is terminated. 

If no DD card has been supplied for the object error data set, error message 
IH0219I is written out on the console and the job is terminated. 



Notes: 
1. 

2. 



Alternatively, the user can set the return code to 0, thus requesting a standard 
corrective action. 

If the error was not caused during asynchronous input/output processing, the user 
exit-routine cannot perform any asynchronous I/O operation and, in addition, may 
not perform any REWIND, BACKSPACE, or ENDFILE operation. If the error was caused 
during asynchronous input/output processing, the user cannot perform any 
input/output operation. On return to the library, the remainder of the 
input/output request will be ignored. 

The user exit routine may supply an alternative answer for the setting of the 
result register. The routine should always set an INTEGER+4 variable and the 
FORTRAN library will load fullword or halfword depending on the length of the 
argument causing the error. 



ERRSET Subroutine 



end of the list reguire no place notation. ) 
CALL ERRSET has the format: 



The CALL ERRSET statement permits the user 
to change up to five different options. It 
consists of six parameters. The last four 
parameters are optional, but each omitted 
parameter must have its place noted by a 
comma and a zero if succeeding parameters 
are specified. (Omitted parameters at the 



CALL ERRSET (ierno, inoal, inomes, 
itrace, iusadr, irange) 



where : 



ierno 



is the error number to be referenced 
in the option table. Should any 



158 



number not within the range of the 
option table be used, an error message 
will be printed. (Note that if ierno 
is specified as 212, there is a 
special relationship between the ierno 
and irange parameters. See the 
explanation for irange. ) 



inoal 

is an integer specifying the number of 
errors psririiuucu uciorc execution is 
terminated. If inoal is specified as 
either zero or a negative number, the 
specification is ignored, and the 
number-of- errors option is not 
altered. If a value of more than 255 
is specified, an unlimited number of 
errors is permitted. 

inomes 

is an integer indicating the number of 
messages to be printed. A negative 
value specified for inomes causes all 
messages to be suppressed; a 
specification of zero indicates that 
the number-of-messages option is not 
to be altered. If a value greater 
than 255 is specified, an unlimited 
number of error messages is permitted. 

itrace 

is an integer whose value may be 0, 1, 
or 2. A specification of indicates 
the option is not to be changed; a 
specification of 1 requests that no 
traceback be printed after an error 
occurrence; a specification of 2 
requests the printing of a traceback 
after each error occurrence. (If a 
value other than 1 or 2 is specified, 
the option remains unchanged. ) 

iusadr 

specifies one of the following: 

1. The value 1, as a 4-byte integer, 
indicating that the option table 
is to be set to show no user-exit 
routine (i.e., standard corrective 
action is to be used when 
continuing execution). 

2. The name of a closed subroutine 
that is to be executed after the 
occurrence of the error identified 
by ierno. The name must appear in 
an EXTERNAL statement in the 
source program, and the routine to 
which control is to be passed must 
be available at link editing time. 

3. The value 0, indicating that the 
table entry is not to be altered. 

irange 

serves a double function. It 
specifies one of the following: 



1. An error number higher than that 
specified in ierno. This number 
indicates that the options 
specified for the other parameters 
are to be a^—lied to the entire 
range of error conditions 
encompassed by ierno and irange. 
(If irange specifies a number 
lower than ierno, the parameter is 
ignored, unless ierno specifies 
the number 212. ) 



2. A print control character if ierno 
specified 212. The value 1 is 
specified to provide single 
spacing for an overflow line 
(standard fixup for WRITE 
statements). If a value other 
than 1 is specified, no print 
control is provided. 



The default value is assumed if the 
parameter is omitted (i.e., no print 
control is provided, and the values 
specified for all parameters apply 
only to the error condition number in 
ierno) . 

Examples of CALL ERRSET are: 

Example 1 : 

CALL ERRSET ( 310, 20, 5, 0, MYERR, 320) 

This example specifies the following: 

1. Error condition 310 (ierno) 

2. The error condition may occur up to 20 
times (inoal) 

3. The corresponding error message may be 
printed up to 5 times (inomes) 

4. The default for traceback information 
is to remain in force (itrace) 

5. The user-written routine MYERR is to 
be executed after each error 
occurrence (iusadr) 

6. The same options are to apply to all 
error conditions from 310 to 320 
(irange) 

Example 2 : 

CALL ERRSET (212,10,5,2,1,1) 
This example specifies : 

1. Error condition 212 

2. The condition may occur up to 10 times 



Extended Error Handling Facility 159 



3. The corresponding message may be 
printed up to 5 times 

4. Traceback information is to be 
displayed after each error occurrence 

5. Standard corrective action is to be 
executed after an error 

6. Print control is to be employed 

For illustration purposes, this 
example explicitly specifies all 
default options except in requesting 
print control. 



Example 3: 

CALL ERRSET (212,010,0,0,1) 

This example illustrates an alternate 
method of specifying exactly the same 
options as the second example. It states 
that no changes are to be made to default 
settings except in requesting print 
control. 



ERRTRA Subroutine 

The CALL ERRTRA statement permits the user 
to dynamically request a traceback and 
continued execution. It has the format: 

CALL ERRTRA 

The call has no parameters. 



USER-SUPPLIED ERROR HANDLING 



The user has the ability of calling, in his 
own program, the FORTRAN error monitor 
(ERRMON) routine, the same routine used by 
FORTRAN itself when it detects an error. 
ERRMON examines the option table for the 
appropriate error number and its associated 
entry and takes the actions specified. If 
a user-exit address has been specified, 
ERRMON transfers control to the 
user-written routine indicated by that 
address. Thus, the user has the option of 
handling errors in one of two ways: (1) 
simply by calling ERRMON without supplying 
a user-written exit routine; or (2) by 
calling ERRMON and providing a user-written 
exit routine. 

In either case, certain planning is 
required at the installation level. For 
example, error numbers must be assigned to 
error conditions to be detected by the 
user, and additional option table entries 



must be made available for these 
conditions. The routine that uses the 
error monitor for error service should have 
the status of an installation 
general-purpose function similar to the 
IBM-supplied mathematical functions. The 
number of installation error conditions 
must be known when the FORTRAN library is 
created at program installation time, so 
that entries will be provided in the option 
table by the ADDNTRY parameter of the 
FORTLIB macro instruction. The error 
numbers chosen for user subprograms are 
restricted in range. IBM-designated error 
conditions have reserved error codes from 
000 to 301. Error codes for 
installation-designated error situations 
must be assigned in the range 302 to 899. 
The error code is used by FORTRAN to find 
the proper entry in the option table. 



To call the ERRMON routine, the 
following statement is used: 



CALL ERRMON (imes, iretcd, ierno 
[, datal,data2, . . . ] ) 



where : 



xmes 



is the name of an array aligned on a 
fullword boundary, that contains, in 
EBCDIC characters, the text of the 
message to be printed. The number of 
the error condition should be included 
as part of the text, because the error 
monitor prints only the text passed to 
it. The first item of the array 
contains an integer whose value is the 
length of the message. Thus, the 
first four bytes of the array will not 
be printed. If the message length is 
greater than the length of the buffer, 
it will be printed on two or more 
lines of printed output. 



iretcd 

is an integer variable made available 
to the error monitor for the setting 
of a return code. The following codes 
can be set: 

— The option table or user- exit 

routine indicates that standard 
correction is required. 

1 — The option table indicates that a 

user exit to a corrective routine 
has been executed. The function 
is to be reevaluated using 
arguments supplied in the 
parameters datal,data2 .... 
For input/ output type errors, the 
value 1 indicates that standard 
correction is not wanted. 



160 



lerno 

is the error condition number in the 
option table. Should any number not 
within the range of the option table 
be specified, an error message will be 
printed. 

datal, data2 . . . 

are variable names in an error- 
detecting routine for the passing of 
arguments found to be in error. One 
variable must be specified for each 
argument. Upon return to the error- 
detecting routine, results obtained 
from corrective action are in these 
variables. Because the content of the 
variables can be altered, the 
locations in which they are placed 
should be used only in the CALL 
statement to the error monitor; 
otherwise, the user of the function 
may have literals or variables 
destroyed. 

Since datal and data 2 are the 
parameters which the error monitor 
will pass to a user-written routine to 
correct the detected error, care must 
be taken to make sure that these 
parameters agree in type and number in 
the call to ERRMON and in a 
user-written corrective routine, if 
one exists. 

Note ; If optimization has been 
requested, current values of variables 
may not be correct. 

An example of CALL ERRMON is: 

CALL ERRMON(MYMSG,ICODE,315,Dl,D2) 

The example states that the message to 
be printed is contained in an array named 
MYMSG, the field named ICODE is to contain 
the return code, the error condition number 
to be investigated is 315, and arguments to 
be passed to the user-written routine are 
contained in fields named Dl and D2. 

Figure 111-18 illustrates the use of the 
CALL ERRSET and CALL ERRMON statements in a 
program utilizing a user-supplied 
subprogram to handle divide-by- zero 
situations. The CALL ERRSET and CALL 
ERRMON statements are highlighted for 
easier reference. 



User-Supplied Exit Routine 



When a user-exit address is supplied in the 
option table entry for a given error 
number, the error monitor calls the 



specified subroutine for corrective action. 
The subroutine may be user-written and is 
called by assembler-language code 
equivalent to the following statement: 

CALL x (iretcd, ierno, datal, data2. .. ) 

where : 



is the name of the subroutine whose 
address was placed into the option 
table by the iusadr parameter of the 
CALL ERRSET statement. 
(Interpretations of the other 
parameters -- iretcd, ierno, datal, 
data2 — are the same as those for the 
CALL ERRMON statement. ) 

If an input/output error is detected 
(i.e., an error for codes 211-237, 
286-288), and the error originally was 
caused by a FORTRAN input/output statement, 
subroutine x must not execute any FORTRAN 
input/output statements, but may issue an 
asynchronous input/output statement. If 
the original error was caused by an 
asynchronous input/output statement, 
subroutine x may issue a FORTRAN 
input/output statement but must not issue 
an asynchronous input/ output statement. 
Similarly, if errors for codes 216 or 
241-301 occur, the subroutine x must not 
call the library routine that detected the 
error or any routine which uses that 
library routine. For example, a statement 
such as 

R = A ** B 

cannot be used in the exit routine for 
error 252, because the FORTRAN library 
subroutine FRXPR# uses the function 
subprogram EXP, which detects error 252. 



Note : Although a user-written corrective 
routine may change the setting of the 
return code (iretcd), such a change is 
subject to the following restrictions: 

1. If iretcd is set to 0, then datal and 
data2 must not be altered by the 
corrective routine, since standard 
corrective action is requested. If 
datal and data2 are altered when 
iretcd is set to 0, the operations 
that follow will have unpredictable 
results. 

2. Only the values and 1 are valid for 
iretcd. A user-exit routine must 
ensure that one of these values is 
used if it changes the return code 
setting. A value other than or 1 
will cause unpredictable results. 



Extended Error Handling Facility 161 



//SAMPLE JOB 1, SAMPLE, MSGLEVEL»1 

//STEP1 EXEC FORTXCLG 

//FORT.SYSIN DD * 

C MAIN PROGRAM THAT USES THE SUBROUTINE DIVIDE 

COMMON E 

EXTERNAL FIXDIV 
C SET UP OPTION TABLE WITH ADDRESS OF USER EXIT 

CALL ERRSET( 302, 30, 5,1, FIXDIV) 

E*0 " ' ■■ ' ' 

C GST VALUES TO CALL DIVIDE WITH 

READ (5,9) A,B 

IFCB) 1,2,1 . ' ' . . . 
2 ' B"*l '■ 

1 CALL DIVIDE ( A, B,C) 
WRITE(6,10>C 

9 FORMAT(2E20.8) 

10 FORMAT (*1*,2E20. 8) 
STOP 

END 

SUBROUTINE DIVIDE (A, B,C> 
C ROUTINE TO PERFORM THE CALCULATION C=A/B 

C IF B=0 THEN USE ERROR MESSAGE FACILITY TO SERVICE ERROR 
C PROVIDE MESSAGE TO BE PRINTED 

DIMENSION MES(4) 

DATA MES(1)/12/,MES(2)/' DIW,MES<3) /• 302I»/,MES («♦)/' B=0V 

DATA RMAX/Z7FFFFFFF/ 
C MESSAGE TO BE PRINTED IS 
C DIV302I B=0 

C ERROR CODE 302 IS AVAILABLE AND ASSIGNED TO THIS ROUTINE 
C STEP1 SAVE A,B IN LOCAL STORAGE 

C STEP2 TEST FOR ERROR CONDITION 

100 IF<E> 1,2,1 

C NORMAL CASE — COMPUTE FUNCTION 

RETURN 
C STEP 3 ERROR DETECTED CALL ERROR MONITOR 

2 CALL ERRMON(MES,IRETCD,302,D,E) 

C STEP 4 BE READY TO ACCEPT A RETURN FROM THE ERROR MONITOR 

IF(IRETCD) 5,6,5 
C IF IRETCD=0 STANDARD RESULT IS DESIRED 

C STANDARD RESULT WILL BE C=LARGEST NUMBER IF D IS NOT ZERO 
C CR C=0 IF E=0 AND D=0 
6 IF(D) 7,8,7 

9 RETURN 

C USER FIX UP INDICATED. RECOMPUTE WITH NEW VALUE PLACED IN E 

5 GO TO 100 

SUBROUTINE FIXDIV (IRETCD, INO, A, B) 
C THIS IS A USER EXIT TO SERVE THE SUBROUTINE DIVIDE 
C THE PARAMETERS IN THE CALL MATCH THOSE USE IN THE CALL TO 
C ERRMON MADE BY SUBROUTINE DIVIDE 

C STEP1 IS ALTERNATE VALUE FOR B AVAILABLE — MAIN PROGRAM 
C HAS SUPPLIED A NEW VALUE IN E. IF E=0 NO NEW VALUE IS AVAILABLE 

COMMON E 

IF<E) 1,2,1 
C NEW VALUE AVAILABLE TAKE USER CORRECTION EXIT 

RETURN 
C NEW VALUE NOT AVAILABLE USE STANDARD FIX UP 
2 IRETCD=0 

END 

/* ■:,■*: -'.. - .-...'.' , . 

//GO.SYSIN DD * 

0.1E00 0.0E00 

Figure 111-18. Sample Program Using Extended Error Handling Facility 
162 



The user-written exit routine can be 
written in FORTRAN or in assembler 
language. In either case, it must be able 
to accept the call to it as shown above. 



\ne±r— evi +■ rrm-J-Tno Tri'.i??1" hi 



= .~1 .-.<-£! A 



subroutine that returns control to the 
caller. 

If the user-written exit routine is 
written in assembler language, the end of 
the parameter list can be checked. The 
high-order byte of the last parameter will 
have the hexadecimal value 80. If the 
routine is written in FORTRAN, the 
parameter list must match in length the 
parameter list passed in the CALL statement 
issued to the error monitor. 

When the extended error handling 
facility encounters a condition or a 
request that requires user notification, an 
informative message is printed. 

The error monitor is not recursive; if 
it has already been called for an error, it 
cannot be re-entered if the user-written 
corrective routine causes any of the error 
conditions that are listed in the option 
table. Boundary misalignment is therefore 
not allowed in a user-exit routine. 

Actions the user may take if he wishes 
to correct an error are described in Tables 
III-4, III-5, and III-6. 



OPTION TABLE CONSIDERATIONS 



Figures 111-19 and 111-20 describe the 
fields of the option table and list the 
default values for the contents of these 
fields. 

When a user-written exit subroutine is 
to be executed for a given error condition, 
the programmer must enter the address of 
the routine into the option table entry 
associated with that error condition. 

Addresses for user-exit subroutines 
cannot be entered into option table entries 
during program installation. An 
installation may, however, construct an 



option table containing user-exit addresses 
and place that option table into the 
FORTRAN library. (Each address must be 
specified as a V-type address constant. ) 
Use Oi. tuxs procedure, 'Cuougn, results in 
the inclusion, in the load module, of all 
such user-exit subroutines by the linkage 
editor. 

If the user-exit address is not 
specified in advance through the use of 
V-type address constants, the programmer 
must issue a CALL ERRSET statement at 
execution time to insert an address into 
the option table that was created during 
program installation. 

The programmer should be warned that 
altering an option table entry to allow 
"unlimited" error occurrence (specifying a 
number greater than 255) may cause a 
program to loop indefinitely. 



CONSIDERATIONS FOR THE LIBRARY WITHOUT 
EXTENDED ERROR HANDLING FACILITY 



When the extended error handling facility 
is not chosen, execution terminates after 
the first occurrence of an error, unless it 
is one caused by boundary misalignment, 
divide check, exponent underflow, or 
exponent overflow. The messages for errors 
205, 215, 216, 218, 221-230, 228, and 
238-3 01 are the same as those with tne 
extended error handling facility. The 
other error messages are of the form 
"IHOxxxI" with no text. 

Without the extended error handling 
facility, ERRMON becomes an entry point to 
the traceback routine. User programs that 
call the error monitor do not have to be 
altered. The error message will be printed 
with a traceback map and execution will 
terminate. 

Note, that if the facility is not 
selected, the ERRTRA, ERRSET, ERRSAV, and 
ERRSTR subprograms are assumed to be user 
supplied if they are called in a FORTRAN 
program. 



Extended Error Handling Facility 163 



| Field | | 
Field | Length | j 
Contents | in Bytes | Default j Field Description 

___!___ J. x ___ ___ 


— - t — T T 

Number | 4 | 97 | Number of entries in the Option Table, 
of entries j | j 
4 4 x 

Boundary | 1 | 40 | Bit 1 indicates whether boundary alignment was 
alignment j j (hexa- j chosen at program installation time. Bits and 2 
j | decimal) j through 7 are reserved for future use. 

| | 1 Bit 1: indicates NOALIGN 
| | | 1 indicates ALIGN 
x 4 4 

Extended | 1 | FF | Indicates whether extended error handling was chosen 
error | j (hexa- j at program installation time, 
handling j j decimal) j 

1 | j FF indicates that extended error handling was 

| | | excluded. 

| | | 00 indicates that extended error handling was 

j | | included. 
4 4 4 

Alignment | 1 | 10 | Maximum number of boundary alignment messages 
count j j | allowed when extended error handling is not chosen. 



,. 4 4 4 ^ 



| Reserved | 
l x. 



Reserved for future use. 



Figure 111-19. Option Table Preface 



164 



Field 
Contents 



Field 
Length 
in bytes 



Defaults- 



Field Description 



Number 
of error 
occurrences 
allowed 



10- 



Number of times this error condition should be 
allowed to occur. When the value of the error count 
field (below) equals this value, job processing is 
terminated. Number may range from to 255. A 
value of means an unlimited number of 
occurrences. 3 



Number 
messages 
to print 



5* 



Number of times the corresponding error message is 
to be printed before message printing is suppressed. 
A value of means no message is to be printed. 



Error 
count 



The number of times this error has occurred. A 
value of indicates that no occurrences have been 
encountered. 



Option 
bits 



42 
(hexa- 
decimal) 



Eight option bits defined as follows (the default 
setting is underscored) : 



Bit 




h— 4 
2 



3 6 



Setting | Explanation 

| No control character supplied for 
j overflow lines. 

1 j Control character supplied to provide 
j single spacing for overflow lines. 



| Table entry cannot be modified. 5 

1 | Table entry can be modified. 



| Fewer than 256 error have occurred. 

1 j More than 256 errors have occurred. 

| (Add 256 to error count field above to 
determine the number. ) 



| Do not print buffer contents with error 
| message. 

1 | Print buffer contents. 



| Reserved. 



i only. 

(Unlimited printing requested; print for 

| every occurrence of error. 



| Do not print traceback map. 

1 | Print traceback map. 

__ + + 

7 | | Reserved. 



User 
exit 



Indicates where a user corrective routine is 
located. A value of 1 indicates that no user- 
written routine is available. A value other than 1 
specifies the address of the user-written routine. 



x The default values shown apply to all error numbers (including additional user 

entries) unless excepted by a footnote. 
2 Errors 208, 210, and 215 are set as unlimited, and errors 205, 217, 230, and 240 are 

set to 1. 
3 An unlimited number of errors may cause the FORTRAN job to loop indefinitely until the 

operator intervenes. 
"Error 210 is set to 10, and errors 205, 217, 230, and 240 are set to 1. 
5 The entry for errors 205, 230, and 240 cannot be modified. 
6 The entry is set to except for errors 212, 215, 218, 221, 222, 223, 224, and 225. 

L 

Figure 111-20. Option Table Entry 



Extended Error Handling Facility 165 



Table III-5. Corrective Action After Mathematical Subroutine Error Occurrence (Part 1 of 4) 
r t t t n 













Options 










L 








FORTRAN 


1 

1 Invalid 




_ _ ^ 

Standard 


r 

User-Supplied 


j Error j 


Reference | Argument 


Corrective Action 


Corrective Action 


j Code | 


(See Note 


1) | 


Range 


(See 


Notes 2 and 3) 


(See Note 4) 


1- +- 




+ 








.| 





1 216 | 


CALL SLITE 


(I) | I>4 




The call is treated 


I 










as a NO 


OP (an instruc- 












tion that requests no 












action be performed) 




1 216 | 


CALL SLITET 
(I, J) 


| I>4 




J=2 




I 


1 241 | 


K=I**J 


1 1=0, 


J<0 


K=0 




I, J 


| 242 | 


Y=X**I 


1 x=o. 


I<0 


If 1=0, 
If KO, 


Y=l 
y=« 


X,I 


| 243 | 


DA=D**I 


1 D=0, 


I<0 


If 1=0, 
If KO, 


Y=l 
Y=« 


D,I 


| 244 | 


XA=X**Y 


1 x=o, 


Y<0 


XA=0 




X,Y 


1 245 | 


DA=D**DB 


1 D=0» 


DB<0 


DA=0 




D,DB 


1 246 | 


CA=C**I 


| C=0+0i, I<0 


If 1=0, 


C=l+0 


c,i 










If KO, 


C=»+0i 




| 247 | 


CDA=CD*I 


| C=0+0i, I<0 


If 1=0, 


C=l+0 


CD, I 










If K0, 


C=«+0i 




1 251 | 


Y=SQRT (X) 


| X<0 




Y=|X|V- 


2 


X 


| 252 j 


Y=EXP (X) 


| X>174.673 


Y=« 




X 


| 253 | 


Y=ALOG (X) 


| X=0 
| X<0 




Y=-» 
Y=log | X 


1 


X 
X 




Y=ALOG10 (X) | X=0 




Y=-« 




X 






| X<0 




Y=log., o 


|X| 


X 


1 254 | 


Y=COS (X) 
Y=SIN (X) 


1 |X|> 


2* 8 *w 


Y=V272~ 




X 


1 255 | 


Y=ATAN2 (X, 


XA) | X=0, 


XA=0 


Y=0 




X, XA 


I i 


_ _-L_ _ 


j 


L _ 


_ _ J 


L 


I Notes : 














| 1. The 


variable types are as 


follows : 










Variable 


Type 












I, J 


INTEGER* 4 












X,XA,Y 


REAL* 4 












D,DA,DB 


REAL* 8 












C,CA 


COMPLEX* 8 












Z , X x i x 2 


Complex variables to 


be given the length of the functioned 






argument when they 


appear. 








CD 


COMPLEX* 16 








| 2. The 


largest number that can be repres 


>ented in floating point 


is indicated by the 


j symbol • . 












j 3. The 


value e=approximately 


2.7183. 








j 4. The 


user- supplied answer is obtained 


by recomputation of the 


function using the 


| value set by the user routine for the 


» parameters listed. 





166 



Table III-5. Corrective Action After Mathematical Subroutine Error Occurrence (Part 2 of 4) 





1 
FORTRAN | Invalid 
Reference j Argument 
(See Note 1) j Range 


| Options 

L _ __ _ 


| Error j 
j Code | 
i j. 


r t 

Standard | User-Supplied 
Corrective Action j Corrective Action 
(See Notes 2 and 3) | (See Note 4) 

L J. 


r — t 

j 256 | 


Y=SINH (X) | |X|<175.366 |Y=(SIN X) • | X 
Y=COSH (X) | |Y=« j 


! 257 j 


Y=ARSIN (X) j !XJ>1 
Y=ARCOS (X) | 


If X>1.0,ARSIN(X)=! _ j X 
If X<-1. 6, ARSIN(X)=-j j 
If X>1.0,ARCOS=0 | 
If X<-1. r ARCOS=Jr j 


1 258 | 


Y=TAN (X) | |X|>(2 i8 )* ff 
Y=CQTAN (X) ! 


Y=l | X 


1 259 | 


Y=TAN (X) | X is too close 
j to an odd 
| multiple of f 


Y = « | X 




Y=COTAN (X) | X is too close 
j to a multiple 
| of n 


Y=« | X 


1 261 | 


DA=DSQRT (D) | D<0 


DA= | D | */ a | D 


| 262 | 


DA=DEXP (D) | DXL74.673 


DA=« | D 


| 263 | 


DA=DLOG (D) | D=0 
| D<0 


DA=-« | D 
DA=log | X | j 




DA=DLOG10 (D) | D=0 
j D<0 


DA=-« | D 
DA=log 10 |X| | 


1 264 | 


DA=DSIN (D) | |D|>2 5 °*" 
DA=DCOS (D) j 


DA=V2/2 | D 


| 265 | 


DA=DATAN2 (D, DB) | D=0, DB=0 


DA=0 | D, DB 


| 266 | 


DA=DSINH (D) | |D|>175.366 
DA=DCOSH (D) | 


DA=(SIN X)» | D 
DA=« | 


1 267 | 

L J.. 


DA=DARSIN (D) | |D|>1 
DA=DARCOS (D) | 
J. 


If X>1. 0,DARSIN(X)=f | D 
If X<-1.0,DARSIN(X)=-f | 
If X>1. 0,DARCOS=0 | 
If X<-1.0 # DARCOS=rr j 
L J. 


r A 

| Notes : 


variable types are as follows: 
Variable Type 
I, J INTEGER*** 
X,XA,Y REAL* 4 
D,DA,DB REAL* 8 
C # CA COMPLEX* 8 
Z,X lr X 2 Complex variables to 
argument when they 
CD COMPLEX* 16 
largest number that can be repres 
30l •. 

value e=approximately 2.7183 
user-supplied answer is obtained 
le set by the user routine for the 




| 1. The 

| 2. The 
| syml 
| 3. The 
| 4 . The 
| vali 


be given the length of the functioned 
appear. 

sented in floating point is indicated by the 

by recomputation of the function using the 
; parameters listed. 



Extended Error Handling Facility 167 



Table III-5. Corrective Action After Mathematical Subroutine Error Occurrence (Part 3 of 4) 



r t t — t — - 






1 1 I 


Options 


1 1 1 


L 






1 1 1 

1 | FORTRAN | Invalid 


r 

Standard 


"T" 


Us er- Supplied 


j Error j Reference j Argument 


Corrective Action 




Corrective Action 


J Code | (See Note 1) j Range 


(See Notes 2 and 3) 




(See Note 4) 


j. + + + 


"+- 




j 268 j DA=DTAN (D) j |X|>2 5 °** 


DA=1 




D 


| j DA=DCOTAN (D) | 








| 269 | DA=DTAN (D) | D is too close 


DA=« 




D 


jl j to an odd n 








j | j multiple of 2 








| | DA=DCOTAN (D) j D is too close 


DA=« 




D 


j | j to a multiple 








1 1 | of ir 








i . i ..,„.,, i i 


-J.. 




r 

j For errors 271 through 275, C=X 1 +iX 2 








T~ ~ ~ T ~ T~ ~ 1 


r~ _ _ _ _ 


"T" 




| 271 | Z=CEXP (C) | X ± >17U.673 


Z=*(COS X 2 + SIN X 2 ) 




C 


| 272 | Z=CEXP (C) | |X 2 |>2 18 ** 


Z=e Xl +0*i 




C 


| 273 | Z=CLOG (C) | C=0+0i 


Z=-«+0i 




C 


| 274 | Z=CSIN (C) | iXil^* 8 ** 


Z=0+SINH(X 2 )*i 




C 


| | Z=CCOS (C) j 


Z=COSH(X 2 )+0*i 






| 275 | Z=CSIN (C) | X 2 >174.673 


Z=«(SIN Xi+iCOS X ± ) 
2 




c 


| | Z=CCOS (C) | 


Z=»(COS Xi-iSIN X ± ) 
2 




C 


| | Z=CSIN (C) | X 2 <-174.673 


Z=«(SIN Xi-iCOS X ± ) 
2 




C 


| | Z=CCOS (C) | 


Z=«(COS X ± +iSIN X ± ) 
2 

L _ 




C 


L A , , , , » J 


_JL. 




r^ 

I Notes : 








|1. The variable types are as follows: 








1 Variable Type 








| I, J INTEGER* 4 








| X,XA # Y REAL* 4 








j D,DA,DB REAL* 8 








| C,CA COMPLEX* 8 








| Z,X lr X 2 Complex variables to 


be given the length of 


the functioned 


| argument when they 


appear. 






j CD COMPLEX* 16 








j 2. The largest number that can be represented in floating point is indicated by the 


j symbol • . 








| 3. The value e=approximately 2.7183 








| 4. The user-supplied answer is obtained 


by recomputation of the function using the 


j value set by the user routine for th« 


; parameters listed. 







168 



Table III- 5. Corrective Action After Mathematical Subroutine Error Occurrence (Part 4 of 4) 



Options 



1 1 






1 


> 


_ T 




H 


I I 


FORTRAN 


S Invalid 


j Standard 


1 


User- Supplied 




1 Error | 


Reference 


j Argument 


Corrective Action 


i 


Corrective Action 




j Code J 


(See Note 1) 


j Range 


| (See Notes 2 and 3) 


i 


(See Note 4) 




I L -.. 




_ j. ± 


.j. 






| For errors 281 
i 


through 285, CD=X ± +iX 2 








T 
















| 281 | 


Z=CDEXP 


(CD) 


| X ± >174.673 


Z=*(COS X 2 +iSIN X 2 ) 


i 
i 


CD 




i i 

| 282 | 


Z=CDEXP 


(CD) 


| |X 2 |>25°*;r 


x 

| z=e 1 +0*x 


i 


CD 




| 283 | 


Z=CDLOG 


(CD) 


| CD=0+0i 


| Z=-»+0i 




CD 




| 284 | 


Z=CDSIN 
Z=CDCOS 


(CD) 
(CD) 


j |X i |>2 5 °*^ 


| Z= 0+SINH(X 2 )*i 
Z— COSH\X 2 /+u*X 




CD 




| 284 | 


Z=CDSIN 
Z=CDCOS 


(CD) 
(CD) 


| |Xi|>2 5 °*^ 


Z=0+0i 




CD 




| 285 | 


Z=CDSIN 


(CD) 


| X 2 >174.673 


Z=»(SIN Xi+iCOS X ± ) 
2 




CD 






Z=CDCOS 


(CD) 




Z=«(COS X ± -iSIN X x ) 
2 




CD 






Z=CDSIN 


(CD) 


| X 2 . -174. 673 


Z=«(SIN Xa.-iCOS X x ) 
2 




CD 






Z=CDCOS 


(CD) 




Z=«(COS Xi+iSIN X ± ) 
2 




CD 




| 290 | 


Y=GAMMA 


(X) 


| X<2~ 252 or 
| X>57.5744 


Y=» 




X 




| 291 | 


Y=ALGAMA 


(X) 


| X<0 or 

| X>4.2937*10 73 


Y=« 




X 




| 300 | 


DA=DGAMMA (D) 


| D<2" 252 or 


DA=« 




D 










| D>57.5774 | 










1 301 i 


DA=DLGAMA (D) 


j D<0 or | 


DA=» 




D 










| D>4.2937*10 73 










L_- . _ _J.. 






._x _ J 


L _ 


.x 




J 


!_-. _ 














1 


I Notes: 
















| 1. The 


variable 


types are as follows: 












Variable Type 












I.J 


INTEGER* 4 












X,XA f Y 


REAL* 4 












D,DA,DB 


REAL* 8 












C,CA 


COMPLEX* 8 












z,x ±l x 2 


Complex variables to 


be given the length of 


the functioned 










argument when they 


appear. 










CD 


COMPLEX* 16 










| 2. The 


largest 


number 


• that can be represented in floating point is indicated by the 




j symbol • • 














1 3. The 


value e= 


approximately 2.7183 










j 4. The 


user-supplied 


answer is obtained 


by recomputation of the function using the 




j value set by 


the user routine for the 


i parameters listed. 









Extended Error Handling Facility 169 



Table III-6. Corrective Action After Program Interrupt Occurrence 



Program Interrupt Messages 



Options 



T T 

Parameters 
Passed to 
User Exit 
(Note 1) 



Error 
Code 



Reason for Interrupt 
(Note 2) 



Standard Corrective Action 



User-Supplied 
Corrective 
Action 



207 



208 



209 



D.I 



D.I 



None 



210 



None 



Exponent overflow 
(Interrupt Code 12) 



Exponent underflow 
(Interrupt Code 13) 

Divide check, integer 
divide (interrupt code 9), 
decimal divide (Interrupt 
Code 11) . floating point 
Code 11), floating point 
divide (interrupt code 
15). See Note 4. 

Specification interrupt 
(interrupt Code 6) occurs 
for boundary misalignment. 
Operation exception 
(interrupt code 1) occurs 
for operation interrupt. 
Other interrupts occur 
during boundary alignment 
adjustment or extended 
precision floating point 
simulation. They will be 
shown with this error code 
and the PSW portion of the 
message will identify the 
interrupt. 



Result register set to the 
largest possible floating 
point number. The sign of 
the result register is not 
altered. 

The result register is set 
to zero. 

For floating point divide, 
where n/0 and n=0, result 
register is set to 0; where 
n*0, result register set to 
largest possible floating 
point number. No standard 
fixup for other interrupts. 

No special corrective 
action other than correct- 
ing boundary misalignments. 



User may alter 
D. (Note 3) 



User may alter 
D. (Note 3) 

See Note 5. 



See Note 5. 



Variable 
D 


Type 
REAL* 8 


I 


INTEGER* 4 



Notes: 

1. The variable types and meaning are as follows: 

Meaning 

This variable contains the contents of the result 
register after the interrupt. 
The variable contains the "exponent" as an integer 

value for the number in D. It may be used to 
determine the amount of the underflow or overflow. 
The value in I is not the true exponent, but what was 
left in the exponent field of a floating point number 
after the interrupt. 

2. A program interrupt asynchronously. Interrupts are described in the appropriate 
principles of operation publication, as listed in the Preface. 

3. The user exit routine may supply an alternate answer for the setting of the result 
register. This is accomplished by placing a value for D in the user-exit routine. 
Although the interrupt may be caused by a long or short floating-point operation, 
the user-exit routine need not be concerned with this. The user-exit routine 
should always set a REAL* 8 variable and the FORTRAN library will load a short or 
long data item depending upon the floating-point operation that caused the 
interrupt. 

4. For floating-point divide check, the contents of the result register is shown in 
the message. 

5. The user-exit routine does not have the ability to change result registers after a 
fixed-point divide check. The boundary alignment adjustments are informative 
messages, and there is nothing to alter before execution continues. 



170 



APPENDIXES 



Appendixes 171 



APPENDIX A: EXAMPLES OF JOB PROCESSING 



The following examples show several methods 
of processing load modules. 



The EXEC statement indicates that the 
load module MATINV is the program to be 
executed. 



Exam ple 1; Submitting a Job Consisting of 
One Job Step 

Prob lem Statement : A previously created 
data set, SCIENCE. MATH. MATRICES, contains a 
set of 80 matrices. Each matrix is an 
array containing REAL* 4 variables. The 
size of the matrices varies from 2x2 to 
25x25; the average size is 10x10. The 
matrices are inverted by a load module 
MATINV in the library MATPROGS. Each 
inverted matrix is written (assume FORMAT 
control) as a single record on the data set 
SCIENCE. MATH. INVMATRS. The first variable 
in each record denotes the size of the 
matrix. 



The input/output flow for the example is 
shown in Figure A-l. The job control 
statements used to define this job are 
shown in Figure A- 2. 



'SCIENCE. 

MATH. 
^MA TRICES, 



MATINV 




Figure A-l. 



Printed 
Output 



Input/Output 
Example 1 



Flow for 



Explanation : The JOB statement identifies 
the programmer as JOHN SMITH and supplies 
the account number 537. Control statements 
and control statement error messages are 
written in the SYSOUT data set. 

The JOBLIB DD statement indicates that 
the private library MATPROGS is to be 
concatenated with the system library. 



DD statement FT08F001 identifies the 
input data set, SCIENCE. MATH. MATRICES. 
(Data set reference number 8 is used to 
read the input data set. ) Assume that this 
data set has been previously created and 
cataloged; therefore no information other 
than the data set name and disposition has 
to be supplied. 



DD statement FT10F001 identifies the 
printed output. (Data set reference number 
10 is used for printed output. ) 



DD statement FT04F001 defines the output 
data set. (Data set reference number 4 is 
used to write the data set containing the 
inverted matrices. ) Because the data set 
is to be created and cataloged in this 
job step, a complete data set specification 
is supplied. The DSNAME parameter 
indicates that the data set is named 
SCIENCE. MATH. INVMATRS. The DISP parameter 
indicates that the data set is new and is 
to be cataloged. SPACE indicates that 
space is to be reserved for 80 records, 408 
characters long (80 matrices of average 
size) ; when space is exhausted, space for 9 
more records is allocated. The space is 
contiguous; any unused space is released, 
and allocation is to begin and end on 
cylinder boundaries. 



DCB indicates that records are 
variable-length (because the size of 
matrices vary) . The record length is 
specified as 2504, the maximum size of a 
variable-length record. The maximum size 
of a record in this data set is the maximum 
number of elements (625) in any matrix 
multiplied by the number of bytes (4) 
allocated for an element, plus 4 for the 
segment control word (SCW). The buffer 
length is specified as 2508 (the 4 extra 
bytes are for the block control word (BCW) 
that contains the length of the block) . 

SEP indicates that read and write 
operations are to take place on different 
channels. 



Appendix A: Examples of Job Processing 173 



Sample Coding Form 


1-10 | H-20 21-30 j 31-40 41-50 1 51-60 61-70 71-60 


||2|3|4|5|6|7|619I0| 1 I2I3W5I6I7I8I9I0 1 l2l3|4|5!6]7|8|9|o! 1 |2l3|4|Si6ir,Bi9!oi 1 i2:3|4]_5"6l7!s!9loll [2|3|«|S|6|7|B|9|0 1 12|3|4|5|6|7|8|9|0 1 121314191617191910 


//.I.N.YERT jp.B, .5 l S 1 7i i jp,H | N i S.»1IT,Hj.M i S i G | L.E i V i E i L,«l. .-..,,, , ......... i . . 




/,/,j,0AL,I,B, ,D,D i D,SHAME=^A.TP,RO l S.S.'.,DI | S.P=pL i P , , 








umw, ,e;x.ec. ps«.w|T.iny. ,..,.; | .,,,,.... , | . , , . i 








/,/,F,T,WF.4Wlj Dp fiS,NAMEpSCIENCE,M:ATH.M,AT i RIC | ES r 0I l S i P-OLD ...,....,.,.., 








'/.FJ.W,Wli AP SYSOUTpA .,,.... j ...,,.... | .... i , ... | .............. i 








/Jfjm0\ } PP P l SN 1 AME ri SCIE,NCE..W.TH..I l NyMA,TJRS.> ,....,.. ..,..,. , 




1 < l < 




/.'. .,,..,, j ,,, , pISP=j(NEyy,pAT,LG ] ) !r UNIT=pA^L i AS,S,,ypLU^ = S,E 1 Rr ( l,08,9 ! W 1| , , , 




1 2 ' 




',', .,,....,.,., l SPAC.EJ=(p.05 r (.80. 1| ?O.rRL j S,E, r Cp;NTI i G,^Rp,UNO i ),,SEPrFT(88 | F i i «) l l ill 




1 ' 3 ' 




//. .,,..,, | ... . l PC.B..(;R.E.Cm.y.B.,.L | R.E.C.L...25.0'f, l B.U.51ZE.=2508 . , , . , . , . . . , , 








.1 1 1 1 1 1 I I I 1 I 1 1 1 1 I 1 I i 1 1 1 1 1 I 1 _1 i i 1 L 1 1 1 1 1 1 1 1 1 1 1 , . 1 , , , , | , , , , | | , ! | | , | | | | 






1 1 1 1 1 1 1 



Figure A- 2. Job Control Statements for Example 1 



Example 2: Submitt ing a Job Consisting of 

Multiple Job Steps 

P roblem Statement : Raw data gathered from 
a rocket test firing is to be converted in 
a report and graphs describing the success 
of the test. The data set RAWDATA contains 
the information gathered from the test 
firing. 

Job step 1 executes the load module 
PROGRD. PROGRD compares the raw data in 
RAWDATA against forecasted results 
contained in the data set PROJDATA, and 
generates the data set SREFDATA containing 
refined data to be passed to the second job 
step. 

Job step 2 executes the load module 
ANALYZ. ANALYZ processes 6REFDATA against 
the data set PARAMS which contains 
parameters used in developing values, and 
generates the data set SVALUES containing 
results to be passed to the third job step. 

Job step 3 executes the load module 
REPORT. REPORT prints the values in 
&VALUES as a series of reports and graphs. 

Figure A- 3 shows the I/O flow for this 
example. Figure A-4 shows the job control 
statements for the job. The load modules 
PROGRD, ANALYZ, and REPORT are contained in 
the private library FIRING. 



Projected 
Data 



Parameters 



/ Raw \ 
I Data J 



Job Step 1: 
Refine Data 



Job Step 2: 
Develop Values 



Job Step 3: 

Generate 

Graphs and 

Reports 



Graphs 

and 
Reports 




Figure A- 3. Input Flow for Example 2 



17H 



Sample Coding Form 



■10 



I 213 4 5 678 9^ 



-20 



21-30 



2[3|4|5|6|7|8|9|0 | I l2|3l4l5[6T7 |8l9T0[7T273i4T5T6}7l8l9|6 



51-60 



TT2l3[4T5T6 ]7i8l9|ol I | 2|3|4l5|6|7|8|9 |0 



61-70 



71-80 



lT2[3l4[5l6|7l8l9|0 I 12|3|4|516|7|8I9I0 



//TE^TFIRE, JOB ,rJOHN l SMITH^MSGL ! EVEL= ! i 



/ l / l J,O l fiL l I,B l P | D ll D l S l NAME=,F |I i RI i N,G l rDIS i Pr(,0L i D ir P,ASS i ), 
//STE.Pl, EX.EC, P,GM=P I R I I 6 I RD, , , , , , , , , , lljL __. 



// F T.lflFflfll, DP, A SNAMEp RAWWAr DiISP-PiLP, A j4 
/,/,F,T,l,l,F«l, .D.D. P^Ki,A,MEr,PRO,J l DATA^ i I i S i P i "- l 1 LP , 



/,/,F,T,l|2,F0,0,l| ,D ,D, DSHAME n&REFiDATA^DISP^CNEyyr PASSyrUKIIJ 



'TAPEjCLS , 



/,/, 



l VO,L.UM l E = (rR l E.TA,IN ir SER= l 2107) 1 ? 



j i i i i i i_ 



I 1 i I I 1_1 L_ 



J 1 1 I l_ 



l D,C,B,^ l D,E,Nr2, r R,EC l FM ^, r B l L i K,SI,Z | E,-'400,), 



-L-J I I L_ 



//STEP2 EXEC PGJi/M.NALYZ 



i i-r i— i i— i' 



_l I I I I I I L. 



_l I I I i I I u 



I I I I L 



/,/,F,T,li7F,00,li PP, DiSNAMEr^^ST.EPlvFTl^F^lrDISP^OL.p 



//F | T,1 I 8,F,0 | 0,1 I ,P,D, p i S,MAMEr,PA,RAMS,rDI|S i P=O l LP l 



/./F.T.ffiFflftl . p,D, P^NAME^&yALMESr DIS P^iHEyy^P ASSl^UNIJ-- 



TAPECLSi 



/,/. 



pCB=(p i E,N=2 i rRE l CF | M=f i rB l LKSIZ j E = 2^ i ^), r VOLUME=,S l ER- 



2,1,06 



/./STEPS, EX.EC ,P,G l M=REP l ORT 



_r ii i i i i i i i i i 



J I I I I I L. 



4" 



// ,F,Tfl8,F0fl,l | ^ P|SNAME | --^. i ST,E i P2 iV F | T i 2,0 l F^ i l ir D i I | SP--QL l D , , , , 

//.FJ.ftFgfll, DP, U.NIT- P.RINT^R , , , , , , , , , , , , , , , , , , , 



111111111111 



Figure A- 4. Job Control Statements for Example 2 



Explanation of Job Co ntrol Stateme nts : I n 
Figure A- 4. the JOB statement indicates the 
programmer's name, JOHN SMITH, and 
specifies that control statements and 
control statement error messages are to be 
written in the SYSOUT data set. Because 
the first positional parameter indicating 
accounting information is omitted, its 
absence is noted by a comma. 

The JOBLIB DD statement indicates that 
the private library FIRING is to be 
concatenated with the system library. 

The EXEC statement STEPl indicates that 
the load module PROGRD is to be executed. 

DD statement FT10F001 and FT11F001 
identify the data sets containing raw data 
(RAWDATA) and the forecasted results 
(PROJDATA) respectively. 

DD statement FT12F001 defines the 
temporary data set S6REFDATA (data set 
reference number 12 is used to write 
6&REFDATA). DISP indicates that the data 
set is new and is to be passed to the next 



job step. UNIT indicates that the data set 
is to be written on one of the units 
contained in the device class TAPECLS. 
VOLUME indicates that the volume whose 
serial number is 2107 is to be used to 
contain the data set. DCB indicates that 
the volume is written in high density and 
that records are fixed-length with FORMAT 
control and a buffer length of 400. 

The EXEC statement STEP2 indicates that 
the load module ANALYZ is to be executed. 

DD statement FT17F001 identifies the 
data set containing refined data. It 
specifies the data set as the one defined 
on DD statement FT12F001 appearing in job 
step STEPl. DISP indicates that the data 
set is to be deleted after execution of 
this job step. 

DD statement FT18F001 identifies a 
previously created and cataloged data set 
PARAMS. 

DD statement FT20F001 defines the 
temporary data set 6VALUES containing the 



Appendix A: Examples of Job Processing 175 



values to be printed. DISP indicates that 
the data set is new and is to be passed to 
the next job step. VOLUME and UNIT 
indicate that the data set is to be written 
on volume 2108 using a device in the device 
class TAPECLS. DCB indicates high density 
and fixed-length records (written under 
FORMAT control) with a buffer length of 
204. 



The EXEC statement STEP 3 indicates that 
the load module REPORT is to be executed. 

DD statement FT08F001 identifies the 
data set containing the values to be 
printed. 

DD statement FT06F001 indicates that the 
device class PRINTER is to be used to print 
the reports (data set reference number 6 is 
used to write the data set). 



Example 3: Updating a Direct- Acce ss Data 

Set 

A data set has been created that contains 
master records for an index of stars. Each 
star is identified by a unique 6-digit star 
identification number. Each star is 
assigned a record position in the data set 
by truncating the last two digits in the 
star identification number. Because 
synonyms arise, records are chained. 



Prob lem Statement : Figure A- 5 shows a 
block diagram illustrating the logic for 
this problem. 

A card data set read from the input 
stream is used to update the star master 
data set. Each detail record in this data 
set contains: 

1. The star identification field of the 
star master record that the detail 
record is to update. 

2. Six variables that are to be used to 
update the star master record. 

The following conventions are observed 
in processing this data set: 

1. The star master record that contains 
the record location counter pointing 
to space reserved for chained records 
is assigned to record location 1. 

2. A zero in the chain variable indicates 
that the end of a chain has been 
reached. 




Yes 




f Stop J 



Randomize Star 

Number to a 
Record Location 



Set Record Position 
in Read Statement 
= Chain Variable 




Write Star / 
Master / m 
Record / 



Update 
Variable in 
Star Master 



Set Chain 
Variable = Record 
Location Counter 




Set Record Position 
in Write Statement 

= Record 
Location Counter 



I 



Increment 

Record Location 

Counter by 1 



Build Star 
Master Record 



Figure A-5. Block Diagram for Example 3 



176 



3. The first variable in each star master 
record is the star identification 
field; the second variable in each 
star master is the chain variable 
pointing to the next record in the 
chain. 



4. Each record contains six other 

variables that contain information 
about that star. 



When a detail record is read, its 
identification field is randomized and the 
appropriate star master record is read* If 
the correct star master record is found, 
the record is to be updated. If a star 
master is not found, then a star master 
record is to be created for that star. 

The last record in the star detail data 
set contains star identification number 
999999 to indicate the end of the data set. 



The star master record that contains the 
record counter is read, placing the record 
location counter in LOCREC. Whenever a 
detail record is read, the identification 
variable is checked to determine if the end 
of the detail data set has been reached. 
The star detail records contain the 
variables A, B, C, D, E, and F. 



The identification number in the detail 
record is randomized and the result is 
placed in the variable NOREC, which is used 
to read a master record. The master record 
contains the star identification number 
(IDSTRM), a chain record location (ICHAIN), 



Id SIX Vui J.QUXCO 11, 



and Z) 



which are to be updated by the variables in 
the star detail records. IDSTRM and IDSTRD 
are compared to see if the correct star 
master is found. If it is not found, then 
the variables containing the chain record 
numbers are followed until the correct star 
master is found or a new star master is 
created. 



Expl anation ; Figure A- 5 is similar to the 
diagram shown in Figure III-2 except Figure 
A-5 includes blocks that describe updating 
variables in master records already present 
in the data set. (Figure III-2 includes 
blocks describing certain operations that 
must be performed when a direct access data 
set is created. ) Also, Figure A-5 is 
adapted to Example 3, while Figure III- 2 is 
more general. Figure A-6 shows the FORTRAN 
coding for this program. 



Job Control Statements; The program shown 
in Figure A-6 is compiled and link edited, 
placing the load module in the data set 
STARPGMS and assigning the load module the 
name UPDATE. The data set that contains 
the star master records was cataloged and 
assigned the name STARMSTR when it was 
created. Figure A-7 shows the job control 
statements needed to execute the module 
UPDATE. 



Appendix A: Examples of Job Processing 177 



^DEFINE FILE 7 ( 1 20001 1 305;E ) NEXJT) ' ; 
C" READ RECORD CONTAINING RECORD LOCATION! COUNTER j 

READ'(7'1 i*101 )l'DSTRto?LOCR.EC .._... .: .. nr .. r • - - 

fnTEXrmgWOl^CllT^"^ LAST STAR DATA RECORD 
2fe "READ'(lil^2)IDSTRDiA.lB>CvDjEiF. 

C .i&l&l&VltillttiWl"' .»; 5TAI, DAT. AND READ . S T« 8 >STE* 

I? J&j^^m^miim^^''^.----- : U 

c is this~!corre!ct star MASTER ..,..-■ i 

' 'IF(I!DSTRD-IDSTRM)21,i22,2.1 ,!.■■•) 

C IS THERE' A chIain VARIAB.LE 
21 IF(IiCHAIN)24>2:4i23 




C N'O-bIeGIN! CONSTRUCTING NJEW MASTER 
c up diaIte CJHAI N JVA_RIAJ.LE_.IN_ L ASjL^IA 

7TT. — ' Trui'rit- I /\r OCT 



24 

C SET 
C REC 



1CH-. 

Writ 

re CO 

qrd l 

NORE 
J. OCR 



RD NUMBER TO BEGIN CONSTRUCTION OF £lEW SffAR M'ASTER|. UPDATE 



ocation coSunter;. bui 

C-LOCREC 
EC-LOCREC+li 



AND CJHAIN 



R__A_frER RJE CORPi AND V>R I Tl=]^ A_tjTj_RE___Rb 



nrr=LO(CREc , 

E(7'NpRECrl03)IDSTRM 



>ICHAINiT}iUiV}X!>Yi2 



LD NEW ST A 



R MASlTER record! 




STER; IN THE CHj 
LOCATION 



ECORD 



AIN 



COUNTER 



Figure A-6. FORTRAN Coding for Example 3 



Sample Coding Form 



I- 10 



H2|3|4|S|6|7|8l9l0 



20 

I|2l3|4l5|6|7|8|9|0 



21-30 



I 121314151617181910 



31-40 



H2I3I415I61718|9|0 



41-50 

II2I3I415I617I819I0 



51-60 

I I213I4I516I71819T0 



61-70 



I|21314|51617|819T0 



//STARDAUP, JOB ,323? \J. ASTRONOMER' iM,SGLEV,EL»l 



//JOB.LIB D.D DSN 1 AME=STARP6MSoDI,SP=OL,D 



71-80 

I |2l3|4|5l6l7T8T9l0" 



// EX.EC P6,M=UPDATE 

1—1 I I I L_l I I I I I I [_ 



//FT07F001, DD DSMAME l =STAR l MSTRvDISP=,OLD 



_l_l L_i I I i I i 



//FT01F001, DD *, 



star; details follow 



Star Detail .Data Set 



i 1 i i—i 



III L_l L_J I I l_ 



/* 



END, OF STAR D.ETAIL.S 



J— 1—1 L_l I i I i 



Figure A-7. Job Control Statements for Example 3 



178 



APPENDIX B: 



ASSEMBLER LANGUAGE SUBPROGRAMS 



A FORTRAN programmer can use assembler 
language subprograms with his FORTRAN main 
program. This section describes the 
linkage conventions that must be used by 
the assembler language subprogram to 
communicate with the FORTRAN main program. 
To understand this appendix, the reader 
should be familiar with the appropriate 
assembler language publication and 
assembler programmer's guide, as listed in 
the Preface. 



used as arguments. Each entry in the 
argument list is four bytes and is aligned 
on a fullword boundary. The last three 
bytes of each entry contain the 24-bit 
address of an argument. The first byte of 
each entry contains zeros, unless it is the 
last entry in the argument list. If tnis 
is the last entry, the sign bit in the 
entry is set to 1. 

The address of the argument list is 
placed in general register 1 by the calling 
program. 



SUBROUTINE REFERENCES 



The FORTRAN programmer can refer to a 
subprogram in two ways: by a CALL 
statement or a function reference within an 
arithmetic expression. For example, the 
statements : 

CALL MYSUB(X,Y, Z) 
I=J+K+MYFUNC(L,M,N) 

refer to a subroutine subprogram MYSUB and 
a function subrpogram MYFUNC, respectively. 

For subprogram reference, the compiler 
generates : 

1. A contiguous argument list; the 
addresses of the arguments are placed 
in this list to make the arguments 
accessible to the subprogram. 

2. A save area in which the subprogram 
can save information related to the 
calling program. 

3. A calling sequence to pass control to 
the subprogram, using linkage 
conventions (Table A-l illustrates the 
use of registers during linkage) . 



Argument List 



The argument list contains addresses of 
variables, arrays, and subprogram names 



Save Area 



The calling program contains a save area in 
which the subprogram places information, 
such as the entry point for this program, 
an address to which the subprogram returns, 
general register contents, and addresses of 
save areas used by programs other than the 
subprogram. The amount of storage reserved 
by the calling program is 18 words. Figure 
A-8 shows the layout of the save area and 
the contents of each word. The address of 
the save area is placed in general register 
13. 

The called subprogram does not have to 
save and restore floating-point registers. 



Call i ng S e quence 



A calling sequence is generated to transfer 
control to the subprogram. The address of 
the save area in the calling program is 
placed in general register 13. The address 
of the argument list is placed in general 
register 1, and the entry address is placed 
in general register 15. If there is no 
argument list, then general register 1 will 
contain zero. A branch is made to the 
address in register 15 and the return 
address is saved in general register 14. 



Appendix B: Assembler Language Subprograms 179 



Table A-l. Linkage Registers 



r t 

Register 
Number 



Register Name 



Function 







Result Register 



Used for function subprograms only. The result is returned in 
general or floating-point register 0. An extended precision 
result is returned in floating-point registers and 2. A 
complex result is returned in floating-point registers (real 
part) and 2 (imaginary part). 

Note ; For subroutine subprograms, the result (s) is returned 



4- 



in a variable (s) passed by the programmer. 



Argument List 
Register 



Address of the argument list passed to the called 
subprogram. 



Result Register 



See Function of Register 0. 



13 



Save Area 
Register 



Address of the area reserved by the calling program 

in which the contents of certain registers are stored by the 

called program. 



14 



Return Register 



Address of the location in the calling program to which con- 
trol is returned after execution of the called program. 



15 



Entry Point 
Register 



Address of the entry point in the called subprogram. 

Note : Register 15 is also used as a condition code register, 
a RETURN code register, and a STOP code register. The parti- 
cular values that can be contained in the register are: 
16 - a terminal error was detected during execution of a sub- 
program (an IHOxxxI message is generated) 
4*i - a RETURN i statement was executed 
n - a STOP n statement was executed 
- a RETURN or a STOP statement was executed 



AREA 

(word 1) 



AREA+4- 



(word 2) 



AREA+8 

(word 3) 

AREA+12-- 
(word 4) 



> r , 

This word is used by a FORTRAN- compiled routine to store its 
epilogue address and may not be used by the assembler language 
subprogram for any purpose. 



AREA+ 16 > 

(word 5) 
AREA+20 > 

(word 6) 
AREA+ 2 4 > 

(word 7) 



If the program that calls the assembler language subprogram is 
itself a subprogram, this word contains the address of the save 
area of the calling program; otherwise, this word is not used. 



The address of the save area of the called subprogram. 



The contents of register 14 (the return address). When the sub- 
program returns control, the first byte of this location is set 
to ones. 



The contents of register 15 (the entry address) 



The contents of register 0, 



The contents of register 1. 



AREA+68 

(word 18) 



>[- 



[The contents of register 12. 



Figure A- 8. Save Area Layout and Word Contents 



180 



CODING THE ASSEMBLER LANGUAGE SUBPROGRAM 



Two types of assembler language subprograms 
are possible: the first type (lowest 
level) assembler subprogram does not call 
another subprogram; the second type (higher 
level) subprogram does call another 
subprogram. 



addition to these conventions, the 
assembler program must provide a method to 
transfer arguments from the calling program 
and return the arguments to the calling 
program, 



Higher Level Asse mbler Language Subprogram 



Codin g a Lowest L evel Assembler Languag e 
Subprogram 



For the lowest level assembler language 



XiiO *-J. *-lV^ 1~.I.W*JL< 



include: 



1. An assembler instruction that names an 
entry point for the subprogram. 

2. An instruction (s) to save any general 
registers used by the subprogram in 
the save area reserved by the calling 
program. (The contents of linkage 
registers and 1 need not be saved. ) 

3. An instruction (s) to restore the 
"saved" registers before returning 
control to the calling program. 

4. An instruction that sets the first 
byte in the fourth word of the save 
area to ones, indicating that control 
is returned to the calling program. 

5. An instruction that returns control to 
the calling program. 

Figure A- 9 shows the linkage conventions 
for an assembler language subprogram that 
does not call another subprogram. In 



A higher level assembler subprogram must 
include the same linkage instructions as 
the lowest level subprogram, but because 
the higher level subprogram calls another 
subprogram, it must simulate a FORTRAN 
subprogram reference statement and include: 

1. A save area and additional 
instructions to insert entries into 
its save area. 

2. A calling sequence and a parameter 
list for the subprogram that the 
higher level subprogram calls. 

3. An assembler instruction that 
indicates an external reference to the 
subprogram called by the higher level 
subprogram. 

4. Additional instructions in the return 
routine to retrieve entries in the 
save area. 

N ote : If an assembler language main 
program calls a FORTRAN subprogram, the 
following instructions must be included in 
the assembler language program before the 
FORTRAN subprogram is called: 

L 15,=V(IBC0M#) 
BAL 14, 64(15) 



T T 

|Oper. | Operand 




Comments 



H 



LM 

MVI 

BCR 



10 

|15,m+l+4(15) 
|X'm' 
|CLm' name' 

I 

|14,R, 12(13) 



BRANCH AROUND CONSTANTS IN CALLING SEQUENCE 

m MUST BE AN ODD INTEGER TO INSURE THAT THE PROGRAM 

STARTS ON A HALFWORD BOUNDARY. THE NAME CAN BE PADDED 

WITH BLANKS. 

THE CONTENTS OF REGISTERS 14, 15, AND THROUGH R ARE 

STORED IN THE SAVE AREA OF THE CALLING PROGRAM. R IS ANY 

NUMBER FROM 2 THROUGH 12. 

ESTABLISH BASE REGISTER (2<B<12) 



IB, 
|*,B 
| (user- written source statements) 



RESTORE REGISTERS 

INDICATE CONTROL RETURNED TO CALLING PROGRAM 

RETURN TO CALLING PROGRAM 



|2,R, 28(13) 

|12(13) I X , FF» 

|15,14 

X 

Linkage Conventions for Lowest Level Subprogram 



Figure A-9. 



Appendix B: Assembler Language Subprograms 181 



These instructions cause initialization of 
return coding, interruption exceptions and 
openinq of the error message data set. If 
this is not done and the FORTRAN subprogram 
terminates either with a STOP statement or 
because of an execution- time error, the 
data sets opened by FORTRAN are not closed 
and the result of the termination cannot be 
predicted. Register 13 must contain the 
address of the save area that contains the 
registers to be restored upon termination 



of the FORTRAN subprogram. If control is 
to return to the assembler language 
subprogram, then register 13 contains the 
address of its save area. If control is to 
return to the operating system, then 
register 13 contains the address of its 
save area. 

Figure A-10 shows the linkage 
conventions for an assembler subprogram 
that calls another assembler subprogram. 



r t 

| Name |Oper. 



| Operand 



Comments 



deckname 



* 

* 

AREA 

* 

probl 



* 

ADCON 

* 

ARGLIST 



START 

EXTRN 

BC 

DC 

DC 

STM 



BALR 

USING 

LR 



LA 
ST 
ST 



BC 
DS 



LA 

L 

BALR 



LM 
L 

MVI 
BCR 

DC 

DC 



DC 
DC 





name 2 

15,m+l+4(15) 

X'm' 

CLm'namel' 

SAVE ROUTINE 

14, R, 12(13) 



B, 
*,B 
Q,13 



13, AREA 
13, 8(0, Q) 
Q, 4(0, 13) 



15, probl 
18F 



NAME OF THE SUBPROGRAM CALLED BY THIS SUBPROGRAM 



THE CONTENTS OF REGISTERS 14, 15, AND THROUGH R ARE 
STORED IN THE SAVE AREA OF THE CALLING PROGRAM. R IS 
ANY NUMBER FROM 2 THROUGH 12. 
ESTABLISH BASE REGISTER 

LOADS REGISTER 13, WHICH POINTS TO THE SAVE AREA OF THE 
CALLING PROGRAM, INTO ANY GENERAL REGISTER, Q, EXCEPT 0, 
11, 13, AND 15. 

LOADS THE ADDRESS OF THIS PROGRAM' S SAVE AREA INTO 
REGISTER 13. 

STORES THE ADDRESS OF THIS PROGRAM' S SAVE AREA INTO THE 
CALLING PROGRAM'S SAVE AREA 

STORES THE ADDRESS OF THE PREVIOUS SAVE AREA (THE SAVE 
AREA OF THE CALLING PROGRAM) INTO WORD 2 OF THIS PRO- 
GRAM' S SAVE AREA 



RESERVES 18 WORDS FOR THE SAVE AREA 
END OF SAVE ROUTINE 
(user-written program statements) 

CALLING SEQUENCE 

1, ARGLIST LOAD ADDRESS OF ARGUMENT LIST 

15, ADCON 

14,15 

(more user-written program statements) 

RETURN ROUTINE 

13.AREA+4 LOADS THE ADDRESS OF THE PREVIOUS SAVE AREA BACK INTO 

REGISTER 13 
2,R,28(13) 
14,12(13) 
12(13), X'FF' 
15,14 

END OF RETURN ROUTINE 
A(name2) 
ARGUMENT LIST 
AL4(arga.) ADDRESS OF FIRST ARGUMENT 



X'80' INDICATE LAST ARGUMENT IN ARGUMENT LIST 

AL3(arg n ) ADDRESS OF LAST ARGUMENT 



LOADS THE RETURN ADDRESS INTO REGISTER 14. 



RETURN TO CALLING PROGRAM 



Figure A-10. Linkage Conventions for Higher Level Subprogram 



182 



In-Line Argument List 



RETRIEVING ARGUMENTS FROM THE ARGUMENT LIST 



The assembler programmer may establish an 
in— line argument list instead of out - of - 
line list. In this case, he may substitute 
the calling sequence and argument list 
shown in Figure A- 11 for that shown in 
Figure A-10. 



The argument list contains addresses for 
the arguments passed to a subprogram. The 
order of these addresses is the same as the 
order specified for the arguments in the 
calling statement in the main program. The 
address for the argument list is placed in 
register 1. For example, when the 
statement: 



|ADCON 


DC 


A(probl) 




LA 


14, RETURN 




L 


15, ADCON 




CNOP 


2,4 




BALR 


1,15 




DC 


AL4 larga.) 




DC 


AL4(arg a ) 




• 

DC 


X 1 80' 




DC 


AL3(arg n ) 


| RETURN 


BC 


O^'isn' 



Figure A-ll. In-Line Argument List 



Sharing Data in COMMON 



Both named and blank COMMON in a FORTRAN IV 
program can be referred to by an assembler 
language subprogram. To refer to named 
COMMON- the V— tvr»e address constant 

name DC V(name of COMMON) 

is used. 

If a FORTRAN program has a blank COMMON 
area and blank COMMON is also defined (by 
the COM instruction) in an assembler 
language subprogram, only one blank COMMON 
area is generated for the output load 
module. Data in this blank COMMON is 
accessible to both programs. 

To refer to blank COMMON, the following 
linkage may be specified: 

COM 
name DS OF 



CALL MYSUB(A,B,C) 



is compiled, the following argument list is 
generated. 



r t 1 

JOOOOOOOOJ address of A j 

}. + ) 

1 00000000 1 address of B j 

|. 4 ., 

| 100000001 address of C j 

L j. j 

For purposes of discussion, A is a REAL*8 
variable, B is a subprogram name, and C is 
an array. 

The address of a variable in the calling 
program is placed in the argument list. 
The following instructions in an assembler 
language subprogram can be used to move the 
REAL* 8 variable A to location VAR in the 
subprogram. 



L 
MVC 



Q,0<1) 
VAR(8),0(Q) 



Q is any general register except 0. 



For a subprogram reference, an address 
of a storage location is placed in the 
argument list. The address at this storage 
location is the entry point to the 
subprogram. The following instructions can 
be used to enter subprogram B from the 
subprogram to which B is passed as an 
argument. 

L Q,4(l) 
L 15,0(Q) 
BALR 14,15 

where : 

Q is any general register except 0. 



cname CSECT 



L ll,=A(name) 
USING name, 11 



For an array, the address of the first 
variable in the array is placed in the 
argument list. An array [for example, a 
three-dimensional array C(3,2,2)] appears 
in this format in main storage. 



Appendix B: Assembler Language Subprograms 183 



0(1,1,1) 0(2,1,1) C(3,l,l) C(l,2,l) 

r 

L-C(2,2,l) C(3,2,l) C(l,l # 2) C(2,l,2) 

L-C(3,l,2) C(l,2,2) C(2,2,2) 0(3,2,2) 



Table A- 2 shows the general subscript 
format for arrays of 1, 2, and 3 
dimensions. 



Example ; An assembler language subprogram 
is to be named ADDARR, and a real variable, 
an array, and an integer variable are to be 
passed as arguments to the subprogram. The 
statement: 

CALL ADDARR (X,Y,J) 

is used to call the subprogram. Figure 
A-12 shows the linkage used in the 
assembler subprogram. 



Table A- 2. Dimension and Subscript Format 



| Array A 
I- 



Subscript Format 



|A(D1) |A<S1) 
|A(D1,D2) |A(S1,S2) 
|A(D1,D2,D3) |A(S1,S2, S3) 

V i. 



Dl, D2, and D3 are integer constants used 
| in the DIMENSION statement. Si, S2, and 
j S3 are subscripts used with subscripted 
| variables. 

L 



The address of the first variable in the 
array is placed in the argument list. To 
retrieve any other variables in the array, 
the displacement of the variable, that is, 
the distance of a variable from the first 
variable in the array, must be calculated. 
The formulas for computing the displacement 
(DISPLC) of a variable for one, two, and 
three dimensional arrays are: 

DISPLC=(S1-1)*L 

DISPLC= (Sl-1) *L+ (S2-1) *D1*L 

DISPLC=(Sl-l) *L+ (S2-1) *D1*L+ (S3-1) *D2*D1*L 

where: 

L is the length of each variable in 
this array. 

For example, the variable 0(2,1,2) in 
the main program is to be moved to a 
location ARVAR in the subprogram. Using 
the formula for displacement of integer 
variables in a three-dimensional array, the 
displacement (DISP) is calcualted to be 28. 
The following instructions can be used to 
move the variable, 

L Q,8(l) 

L R,DISP 

L S,0(Q,R) 

ST S, ARVAR 

where : 

Q and R are any general registers 
except 0. 

S is any general register. Q and R 
cannot be general register 0. 



RETURN i in an Assembler Language 
Subprogram 



When a statement number is an argument in a 
CALL to an assembler language subprogram, 
the subprogram cannot access the statement 
number argument. 

To accomplish the same thing as the 
FORTRAN statement RETURN i (used in FORTRAN 
subprograms to return to a point other than 
that immediately following the CALL) , the 
assembler subprogram must place 4*i in 
register 15 before returning to the calling 
program. 

For example, when the statement: 

CALL SUB (A, B, £10, £20) 

is used to call an assembler language 
subprogram, the following instructions 
would cause the subprogram to return to the 
proper point in the calling program: 



LA 15,4 (to return to 10) 
BCR 15,14 

LA 15,8 (to return to 20) 
BCR 15,14 



OBJECT-TIME REPRESENTATION OF FORTRAN 
VARIABLES 



The programmer who uses FORTRAN in 
connection with assembler language may need 
to know how the various FORTRAN data types 
appear in the computer. The following 
examples illustrate the object-time 
representation of FORTRAN variables as they 
appear in System/360 and System/370. 



184 



r t t 

| Name | Operation! Operand 



ADDARR 

B 



INDEX 
I VAR 



[START 

EQU 
|BC 

DC 
|DC 

STM 
iBALR 

USING 

L 

MVC 
|L 

MVC 

L 



LM 
|MVI 

BCR 
|DS 

DS 
IDS 




8 

15,12(15) 
X«7' 

CL7' ADDARR' 
14, 12,12(13) 
B, 
*,B 
2,8(1) 

INDEX(4),0(2) 
3,0(1) 

| VAR ( 4 ) , ( 3 ) 
4,4(1) 



MOVE 3RD ARGUMENT TO LOCATION CALLED 
INDEX IN ASSEMBLER LANGUAGE SUBPROGRAM. 
MOVE 1ST ARGUMENT TO LOCATION CALLED VAR 
IN ASSEMBLER LANGUAGE SUBPROGRAM. 
LOAD ADDRESS OF ARRAY INTO REGISTER 4. 



(user-written statements) 



2,12,28(13) 

12(13), X'FF' 

15,14 

OF 

IF 

IF 



Figure A-12. Assembler Subprogram Example 

INTEGER Type 

INTEGER values are treated as fixed-point operands by the compiler, and are governed by 
the principles of System/360 and System/370 fixed-point arithmetic. INTEGER values are 
converted into either fullword (32-bit) or half word (16-bit) signed integers. 

Example: INTEGER* 2 ITEM/76/, VALUE 

INTEGER+4 F,F64/100/ 
F = 15 
VALUE =-2 



<- 



2 Bytes- 



r~T t n 

ITEM | 0| 0000000 | 01001100 | 

L_X X J 



S 1 



15 



■2 Bytes - 



r~T t 1 

VALUE | 1 | 1111111 | 1111111 | 
L_X X J 



S 1 



15 



<- 



■4 Bytes - 



r~T T T T 1 

| 0| oooooooi ooooooooi ooooooooi 000011111 

L_X X X J. J 

SI 31 



-4 Bytes- 



F64 | 0|0000000 | 00000000 | 000000001 011001001 

L_J. JL JL X J 



S 1 



31 



where S in bit position represents the sign bit. All negative numbers are represented 
in two's complement notation with a one in the sign-bit position. (For a more complete 
explanation of fixed-point arithmetic, refer to the appropriate principles of operation 
publication, as listed in the Preface. ) 



Appendix B: Assembler Language Subprograms 185 



REAL Type 

All REAL variables are converted into short (32 bit), long (64 bit), or extended (128 
bit) floating-point numbers by the compiler. The length of the numbers is determined by 
FORTRAN IV specification conventions. 

Example : REAL* 4 HOLD,R/100./ 
REAL*8 A,RATE/-8./ 
REAL* 16 X 
HOLD = -4. 
A = 8.0D0 
X = 2. 0Q0 

The values of the variables appear in storage as follows: 

< 4 Bytes > 

S C F 

r _ T T T T 1 

HOLD 1 1 1 10000011 01000000 j 00000000 | 00000000 j 

L_X X X X J 

17 8 31 



< 4 Bytes > 

S C F 

r~T T T T 1 

R | 0| 10000101 011001001 ooooooooi ooooooooi 

L_X X X X J 

17 8 31 



< 8 Bytes- 

S C F 



Tooooi 



r~T T T T T 

| 0| 10000011 ioooooooi ooooooooi ooooooooi 0000 

L_X X X X J 

17 8 31 63 



< 8 Bytes 

S C F 

r~T T T T T 

RATE 1 1 1 1000001 j 10000000 j | 00000000 | 00000000 j 0000 



f 0000 j 



17 8 31 63 



< 16 Bytes > 

S C F S C F 
r _ T T T T . . T _ T T ., 

X j 1 1000001J 00100000|00000000|000< s oojojoiiooiijoooo ] < 0000 j 

L_X X X X £ \ X_X X i i J 

17 8 63 64 65 71 72 127 

Legend : 

S (sign bit) occupies bit position 0. 

C (characteristic), or exponent, occupies bit positions 1 through 7. 

F (fraction) occupies either bit positions 8 through 31 for a short, floating-point 
number; bit positions 8 through 63 for a long, floating-point number; or bit 
positions 8 through 63, 72 through 127 for an extended-precision floating-point 
number (bit positions 64-71 represent a sign + characteristic having a value 14 
less than the data represented in bits through 7). 



186 



COMP LEX Type 

A COMPLEX variable has two parts (real and imaginary) and is treated internally as a pair 
of REAL numbers. The COMPLEX parts are converted into two short, long, or extended 
floating-point numbers. 

Example; COMPLEX D/(2. 1, 4.7)/, E*16, Z*32 
E = (55,5D0-55.5D0) 
Z=(2.0Q0,4. OQO) 

The values of the variables D, E, and Z appear in storage as follows: 

< 4 Bytes > 

S C F 

r—i t 1 t 1 

D |0|1000001|0010000ljl001100ljl001100lj 2.1 

|._ + x 4 + .j 

I 1 1000001 1 01001011 1 001100111 001100111 4.7 

L_X JL X X J 

17 8 31 
< 4 Bytes > 



< 8 Bytes > 

S C F 

foIl00001oIo011011ljlOOOOOOO|00000000|OOOol f 0000 | 55. 5D0 

|._ + x x ± x iL -i 

|1|1000010|00110111|10000000|00000000| 0000JS 0000| -55.5D0 

L_-L X X X X S < J 

17 8 31 63 

< 8 Bytes > 



< 16 Bytes > 

S C F S C F 

r~T T T 1 < T~T T 1 5 1 

|0|1000001|00100000|000<S 00001 0| 01100111 0000 { > 00001 2. OQO 

I oj ioooooi i oiooooooi ooolToooo i o| oiiooni ooool Tooooi 4. OQO 

1 7 8 63 64 65 71 72 127 

< 16 Bytes > 



Appendix B: Assembler Language Subprograms 187 



FORTRAN IV LOGICAL variables may specify only 2 values: 

.TRUE. or .FALSE. 

These logical values are assigned numerical values of ' 1' and '0', for .TRUE. and 
.FALSE., respectively. 

Example: LOGICAL+1 LI, L2/. TRUE. / 
LOGICAL+4 L3.L4 /.FALSE./ 
LI = .FALSE. 
L3 = .TRUE. 

The variables Ll, L2, L3, and LU are assigned the following values (using hexadecimal 
notation) : 

< — 1 Byte — > 
LI | 00 | 

L J 



< — 1 Byte — > 

r 1 

L2 | 01 | 



-4 Bytes- 



r t t t 1 

L3 | 00 | 00 | 00 | 01 | 

L ± -L X J 



< 4 Bytes > 

L4 | 00 | 00 | 00 | 00 | 

L X J. 1 J 



The DUMP or PDUMP subroutine can also be used as an additional tool for understanding 
the object- time representation of FORTRAN data. Refer to the "Use of DUMP and PDUMP" 
section in the "Programming Considerations" chapter of this publication or consult the 
FORT RAN IV Librar y Subprograms publication. 



APPENDIX C; 



UNIT TYPES 



The UNIT parameter of the DD statement can 2303 

identify an input or output unit by its 2311 
actual address, its type number, or its 

group name. Type numbers, automatically 2314 

established at system generation, 2321 
correspond to units entered into system 

configurations. Type numbers and 3330 
corresponding units are listed here for the 

reader's convenience. 2305 



2303 Drum Storage Unit** 
Any 2311 Disk Storage 

Drive** 
2314 Storage Facility 
Any bin mounted on a 2321 

data cell drive** 
3330 Disk Storage Facility* 

2305 Drum Storage Unit* 



Tape Units 



Unit Record Equipment 



Type 
2400 



2400-1 



2400-2 



Des cription 

2400 series 9-Track Magnetic 
Tape Drive that can be 
allocated to a data set 
written or to be written 
in 800 bpi density 

2400 series Magnetic Tape 
Drive with 7-Track 
Compatibility and without 
Data Conversion 

2400 series Magnetic Tape 
Drive with 7-Track 
Compatibility and Data 
Conversion 



Type Description 
1052 1052 Printer-Keyboard 
1403 1403 Printer or 1404 Printer 
(continuous form only) 

1442 1442 Card Read Punch 

1443 any 1443 Printer 
2501 2501 Card Reader 
2520 2520 Card Read Punch 

2540 2540 Card Read Punch (read 

feed) 
2540-2 2540 Card Read Punch (punch 

feed) 
2671 2671 Paper Tape Reader 
3211 3211 Printer* 



2400-3 2400 series 9-Track Magnetic 
Tape Drive that can be 
allocated to a data set 
written or to be written 



Grap hic Units 



2400-4 2400 series 9-Track Magnetic 
Tape Drive having an 800 
and 1600 bpi capability 



Direct Access Units 



Type Description 
1053 1053 Model 4 Printer 
2250-1 2250 Display Unit, Model 1 
2250-3 2250 Display Unit, Model 3 
2260-1 2260 Model 1 Display Station 

(Local Attachment) 
2260-2 2260 Model 2 Display Station 

(Local Attachment) 
2280 2280 Film Recorder 
2282 2282 Film Recorder-Scanner 



T ype 
2301 
2302 



Description 

2301 Drum Storage Unit 

2302 Disk Storage Drive 



♦Used with System/370 models only. 
♦♦Used with System/360 Models only. 



Appendix C: Unit Types 189 



APPENDIX D: AMERICAN NATIONAL STANDARD CARRIAGE CONTROL CHARACTERS 



The following are the carriage control characters supported by the FORTRAN IV language, 
Code Interpretation 

blank Space one line before printing 

Space two lines before printing 
+ Suppress space before printing 

1 Skip to first line of a new page 



190 



INDEX 



(Where more than one page reference is given, the major reference appears first. ) 



to define temporary data sets 21, 44 
in EXTERNAL statement 126 
in symbolic parameters 88 

use in library functions 126 

as a DD statement parameter 

description of 4 2 

example of 42 

function of 39 

restriction with cataloged 
procedures 81 
to define a data set in a job step 44 
to describe compiler map variables 105 
to identify linkage editor control 
sections 108,109 



-too -l n i, 
J- o J — J-OH 



/* 



// 



as job control statement identifiers 

as job control statement identifiers 
//* 

as job control statement identifiers 
* (apostrophe) in PARM parameter 34 
♦PROCESS statement 55 



22 



22 



22 



to describe compiler map variables 105 

to identify carriage control 
characters 50 

as an output class 55, 28 

in program interrupt message 113,116 
ABEND dump 115 
abnormal termination 

dump 115 

message 101 
accounting information 

in EXEC statement 35 

parameter in JOB statement 
description of 25 
ACCT parameter 

description of 35 

function of 31 
AD (see AUTODBL compiler option) 
addressing exception code 114,116 
ADDRSPC parameter 

in EXEC statement 36-37,32 

in JOB statement 29-30,27 
ALC compiler option 55,138 
alignment routine 113 
ALIGN2 subparameter 6 2 
American National Standards Institute 

(ANS) 55 
ANSF, as a compiler option 55 
API (see Automatic Precision Increase) 
apostrophe, in PARM parameter 34 



argument list 179 

in-line 183 

retrieving arguments fror 
Arithmetic IF statement 121 
array 

dumping an 131 

initializing an 123-124 

notation in input/output statement 

\s vci. x. J.OW \JX. cXCUICiiU J.U ±4.3 

programming considerations 121 
retrieving element from 18 3 
ASCII data sets 

contrasted with EBCDIC data sets 68 
description of 6 8 
example in specifying 69 
identifying an 51 

job control language considerations 
BUFOFF subparameter 51-52 
DCB parameter 76-7 9 
DEN parameter 76 
LABEL parameter 76 
OPTCD suoparameter 52 
restrictions in use of 68,77 
assembler language 

subprogram, example of 18 5 
use of 179-184 
Assigned GO TO statement 128 
associated variable 16 
asynchronous input/output 

affected by automatic precision 

increase 140 
extended error handling 

considerations 161 
programming considerations 121-122 
AUTODBL compiler option 

description of 135-137, 54 
examples of 138 
automatic call library 60 
Automatic Function Selection 126 
Automatic Precision Increase 
description of 134-135 
programming considerations 138-140 
use of AUTODBL option 54,135-137 



B 

to specify blocked records 
description of 50, 73 
example in 75 
as an output class 55 
BACKSPACE statement 

asynchronous input/output 

considerations 121 
programming considerations 122 
restrictions with 122 
BAL assembler instruction 

use in tracing errors 113,114 



121 



Index 191 



base registers 128 
batch compilation 

example of placement of job control 
statements 13 
BCD, as a compiler option 54 
BFALN subparameter 14 
bits per inch 51 
BLKSIZE subparameter 

ASCII data set considerations 76-79 

asynchronous input/output 
considerations 121 

compared to LRECL subparameter 50 

default values of 

for compiler data sets 57 
for load module data sets 72 

description of 50 

direct-access data set 
considerations 80 

EBCDIC data set considerations 73-76 

example of 50 

maximum values of 73 

programming considerations 130 

use of 

in fixed-length records 73 
in undefined-length records 74 
in variable-length records 73 
block control word 50,73 
BLOCK DATA subprogram 

use in overlay programs 145 
block length 

maximum value of 5 

specifying 50 
block prefix 76,77 

boundary alignment considerations 133 
BOUNDRY option 133,113 
bpi (bits per inch) 51 

braces, use in job control language 24 
brackets, use in job control language 24 
branch considerations 128 
buffer length 

specifying 51 
buffers 

programming considerations 130 

specifying number of 51 
BUFNO subparameter 

asynchronous input/output 
considerations 121 

default values of 

for compiler data sets 57 
for load module data sets 72 

description of 51 

programming considerations 130 
BUFOFF subparameter 

description of 51 

examples of 78-79 
built-in functions 136 
BXLE assembler instruction 128 



to describe compiler map variables 105 
to specify chained scheduling 52 

CALL loader option 64 

CALL statement, restrictions 133 

calling seguence 179 

card deck input, specifying 19 



card punch 

BLKSIZE values for 73 
card reader 

BLKSIZE values for 73 
carriage control characters 50 

summary of 190 
cataloged data set 

contrasted with cataloged procedure 15 
description of 15 
cataloged procedure library 13, 81 
cataloged procedures 

contrasted to executable program 13 
description of 81-93,13 
examples in use of 19-20 
location of 15 
modifying 

example in 93 
DD statement 91-92 
EXEC statement 91 
PROC statement 90 
with symbolic parameters 88-89 
naming through PROC parameter 33 
overriding parameters in 91 
restrictions 81 
CATLG, as a DISP subparameter 45 
chained scheduling 
restrictions 121 
specifying 52 
chaining 

in direct access programming 124-125 
channel, input/output 48-49 
CLASS parameter 

description of 28 
function of 28 
comments field, in job control statements 
description of 23 
function of 22 
COMMON area 

using assembler language 

instructions 183 
in overlay programs 144-145 
COMMON block 

storage map of 106, 107 
COMMON statement 

automatic precision increase 

considerations 138-139 
with EQUIVALENCE statement 122 
with OPTIMIZE option 128 
programming considerations 122-123 
compilation 

batch 55,12 

cataloged procedures for 
description of 89 
FORTXC 82 
FORTXCG 87 
FORTXCL 83 
FORTXCLG 85 
compile job step 

cataloged procedures describing 89 
example of job control statements 13 
input to, description of 53-57 
output from, description of 99-107 
compiler 

cataloged procedures 89 
map 

affected by automatic precision 

increase 140 
description of 105-106 



192 



example of 104 

specifying with MAP option 54 
messages 101 
name of 53 
names 

.-rev-. -.*-i .-. -! "J O 

handling of 127 

optimization techniques 127-129 

output 16 

program 

as a language translator 12 
as a processing program 53 

restrictions 132-133 

statistics 100 

storage requirements 131-132 
use of SIZE option 54 
compiler data sets 

DCB default values for 57 

description of 55-57 

summary of 14,57 
compiler options 

changing during a batch compilation 55 

description of 53-56 

example of output from 100,102-104 

format of 53 

summary of 56 
COMPLEX items 

padding 137 

promoting 134-135 

storage representation of 187 
COND parameter 

cataloged procedure use of 89 

in EXEC statement 

contrasted with JOB statement 

parameter 35 
description of 35 

in JOB statement 

description of 27-28 
function of 27-28 
condition code 

compared to return code 28 

specifying to bypass job step 
processing 35 

specifying to terminate job 
processing 28 
constants, promotion of 134 
CONTIG, as a SPACE subparameter 47 
continuation of job control statements 23 
control program, description of 11 
control section 108 

in overlay programs 146 
control statements, linkage editor 

ENTRY statement 148 

IDENTIFY statement 62 

INCLUDE statement 61,147 

INSERT statement 146-147 

LIBRARY statement 61 

ORDER statement 62 

OVERLAY statement 146 

PAGE statement 62 
control word 

segment 50 

block 50 
COPIES parameter 

description of 45 

function of 40 
cross reference listing 

compiler 



description of 101 
example of 102 
specifying 54 
linkage editor 

description of 108 
example of 109 
in overlay programs 
specifying 58 
CYL, 

as a SPACE subparameter 



148 



47 



D 

to describe compiler map variables 105 
to specify variable-length 
records 50,77 
DAT feature 11 
data 

alignment 55 
conversion of 134-140,54 
exception code 115,116 
padding 134 
promotion 134-135 
Data Initialization Statement 

programming considerations 123-124 
data management routines 

description of 12 
DATA parameter 

description of 42 
function of 39 
restrictions 81 
data set 
ASCII 

DCB considerations 76-79 

DCB subparameters 49-51 

description of 68 

example of 69 
cataloged 15 

channel assignment for 48-49 
concatenating a 42 
creating a 21,69 
DCB 

considerations 71-80 

default values 57,72 
defined 14 
direct-access 

DCB considerations 80 

DCB DSORG subparameter 52 

description of 71,15 

examples of 

creating and retrieving 72 
updating 176-178 

space allocation for 47 
disposition of 44-46 
EBCDIC 

DCB considerations 73-76 

description of 68 

examples of 69 
identifying a 43 

input/output allocation for 46-47 
job step use of 

compiler 55-57,14 

linkage editor 59-61,14 

load module 67-72,14 

loader 65-66,15 
label 47-4 8 
location of 42-43 



Index 193 



naming a 42, 43 
partitioned 

DCB considerations for 73-76 
description of 70-71,15 
examples of 

creating 70 

deleting a member of 72 
retrieving 70 
permanent 21 
pre-allocated 130 
record characteristics of 48-52 
retrieving a 21 
seguential 

DCB considerations for 
ASCII 76-79 
EBCDIC 73-76 
description of 68,15 
examples of 69 
space allocation for 47 
system 14-15 
temporary 21 
unit record 69 
user 15 
data- set name 

as a DCB subparameter 49 
data set reference number 
defined 14 
restriction 133 
use of 41, 67 
DBL, as an AUTODBL value 135 
DBLPAD 135,139 
DBLPAD 4 135 
DBLPAD 8 135 
DBL4 135 
DBL8 135 
DCB parameter 49-52 

asynchronous input/output 

considerations 121 
data set definition considerations 
description of 77-8 
summary of 71-72 
default values 

for compiler data sets 57 
for load module data sets 72 
description of 49-52 
examples of 52 
function of 41 

programming considerations 130 
use with * DD parameter 42 
DD statement 

description of 37-52,12 
examples of 38,173 
format of 37 
function of 39-41, 22 

modifying in cataloged procedures 91-92 
naming a 42 
summary of 37 
uses of 41-42 
ddname 

description of 42 
function of 39 
qualified 19 
DDNAME parameter 

description of 43 
function of 39 
deck, object module 

description of 106-107 
specifying 53 



DECK compiler option 53 

dedicated workfile (see pre-allocated data 

set) 
DEFINE FILE statement 

direct-access data set relationship 71 

overlay program use 142 

programming considerations 125 
DELETE 

as DISP subparameter 45, 21 

contrasted with KEEP subparameter 21 
delimiter statement 

cataloged procedure 
considerations 81,19 

description of 12, 22 
DEN subparameter of DCB parameter 51 

default values for load module data 
sets 72 
detail record 124 
device 

class 14,46 

type, summary of 189 
diagnostic messages 

description of 101 

example of 100 

specifying level of to be printed 55 
dictionary 

external symbol 106 

relocation 106 
direct-access data set 

creating a 72,125-126 

DCB considerations 80,52 

default values for 72 

description of 71,15 

retrieving a 72 

updating a 176-178 

using with non-FORTRAN processors 80 
direct access device 

BLKSIZE values for 73 

space allocation for 47 

summary of types 189 
direct-access input/output 
considerations 124-126 

affected by automatic precision 
increase 140 
DISP parameter 

description of 45-46 

example of 46,21 

function of 40 

programming considerations 130 
disposition message 108,109 
divide by zero 

exception code generated 115 
DLM parameter 

description of 42 

function of 39 
DO, implied 121,132 
DO loop 132 

dominance relationships 105 
DPRTY parameter 

description of 35-36 

function of 32 
DSNAME parameter 

description of 43 

function of 40 
DSORG subparameter 

description of 52 

direct-access data set consideration 80 



194 



DUMMY parameter 

description of 43 
function of 39 

dump 

requesting a 115-116 

specifying DD statements 42 

using DUMP and PDUMP subprograms 131 

DUMP compiler option 55 

DUMP library subprogram 139 

DVCHK subprogram 131 



to describe compiler map variables 105 
EBCDIC 

compiler option 54 

da^a cof 

DCB considerations 73-76 
description of 68 
EDIT (see FORMAT compiler option) 
edited source listing 

(see also structured source listing) 

description of 105 

example of 104 
element, array 123 

ellipsis, use in job control language 24 
END card in object module 107 
END= option in READ statement 70-71 
ENDFILE statement 

asynchronous input/output 
considerations 121 
ENTRY linkage editor control statement 

description of 148 

example of 149 
environment, operating (see 
Multiprogramming with a Fixed Number of 
Tasks; Multiprogramming with a Variable 
Number of Tasks) 
EP loader option 65 
EQUIVALENCE statement 

affected by automatic precision 
increase 138-139 

COMMON statement considerations 122 

DATA statement considerations 123 

padding items 137,138 

programming considerations 125-126 

storage map for 106,107 
ERR parameter in READ statement 129 
ERRMON 

description of 160-161,154 

example of 162 
error code diagnostic message 

description of 111 

example of 112 
error correction 

extended error handling facility 
considerations 156 

summary of 

for mathematical subroutines 166-169 
for program interruptions 170 

user-supplied 160-161 
error message, description of 101 
error monitor 160-161,154 
ERRSAV subroutine 156 
ERRSET subroutine 

description of 158-160 

examples of 159-160,162 



ERRSTR subroutine 156 
ESD card 106-107 
exception codes 114-115 
exceptions, correction for 

exponent overflow 170 

exponent underflow 170 

floating-point-divide 170 

operation 170 

specification 170 
exclusive references, in overlay 

programs 144 
EXEC statement 30-37 

automatic precision increase 
options 135-138 

calling cataloged procedures 13 

description of 30-37,12 

examples of 32 

format of 30 

functions of 31-33,22 

modifying in cataloged procedures 91 

restriction in use of 81 

summary of 30 
execute job step (see load module execution 

job step) 
exponent-overflow exception code 115, 116 
exponent-underflow exception code 115, 116 
expression evaluation 129 
extended error handling facility 

description of 154,156 

message IHO210 with 116 

OPTIMIZE option considerations 128 

option table 154-156 

READ statement considerations 129 

sample program using 162 

subprograms in use of 156,158-160 
external function 

in compiler map 105 
external references 

defined 59 

in compiler map 105 
EXTERNAL statement 

programming considerations 126 
external symbol dictionary 106 



to describe compiler map variables 105 
to specify fixed-length records 
description of 50,73 
example of 75 
FIND statement 125 
fixed-length records 

BLKSIZE value for 73 
DCB considerations 

for ASCII data sets 76,78 
for direct-access data sets 80 
for EBCDIC data sets 73,75 
description of 73, 50 
examples of 75 
fixed-point-divide exception code 115, 116 
fixed-point overflow 121 
FLAG compiler option 55 
floating-point-divide 

error, correction for 170 
exception code 115,116 
FMT (see FORMAT compiler option) 



Index 195 



FORMAT compiler option 

example of output 104 

relationship to OPTIMIZE option 54 
FORMAT statement 

restrictions 132 
formatted records 

ASCII data sets 76 

DCB considerations for 
description of 73-74 
examples of 75-77 

direct-access data sets 80 

EBCDIC data sets 73-74 
FORT, as a name in cataloged 

procedures 8 5,89 
FORT. SYS IN 19 
FORTLIB, as subroutine library (see 

SYSl.FORTLIB) 
FORTLIB macro instruction 154,160 
FORTRAN library 

programming considerations 130-131 

subprograms 

affected by automatic precision 

increase 139 
location 16 
FORTXC 

format of 82 

placement of job control statements 19 
FORTXCG 

format of 87 

placement of job control statements 20 
FORTXC L 

format of 83 

placement of job control statements 19 
FORTXCLG 

format of 85 

placement of job control statements 19 
FORTXG 

format of 86 

placement of job control statements 20 
FORTXL 

format of 88 

placement of job control statements 20 
FORTXLG 

format of 84 

placement of job control statements 20 
FT05F001 DD statement 

DCB default values for 72 

description of 67, 15 

SYSIN DD statement 67 
FT06F001 DD statement 

DCB default values for 72 

description of 67, 15 
FT07F001 DD statement 

DCB default values for 72 

description of 67, 15 
functions, promotion of 

built-in 136 

library 136,134 



generic names 133 
GENERIC statement 

programming considerations 
GO, as a name in cataloged 

procedures 85,90 
GO. SYSIN 19 



GOSTMT compiler options 

description of 54 

relationship to traceback map 111 

use in tracing errors 113 
graphic units 

summary of types 189 



(H Extended) compiler 

location of 16 
hierarchy support 29 



12 



126 



IBCOM 111 

ID (see GOSTMT compiler option) 

IDENTIFY statement 62 

IEHPROGM 71,72 

IEWL 5 8 

IEWLDRGO 63 

IF statement 

Arithmetic 121 

Logical 127 
IFE, to identify the compiler 101 
IFEAAB 53 
IHO210I error message 

description of 113-115 

format of 116 

implied DOs 121 

restrictions 132 
imprecise interruption 113 
IN, as a LABEL subparameter 48 
INCLUDE linkage editor control statement 

description of 61 

in overlay program 147 

example of 61 
inclusive references, in overlay 

programs 143 
INCRES, as an ASCII option 68 
INCTRAN, as an ASCII option 68 
indicative dump 115 
induction variables 128 
information message 101 
informative messages 

description of 99 

example of 100 
input, card deck 19 
input job stream 11 
input/output 

affected by automatic precision 
increase 140 

asynchronous programming 
considerations 121-122 

direct access considerations 124-125 

list-directed 127 

operations 48 

unformatted 127 
input/output statements 

array notation in 121 

relationship to DD statements 14-15 
INSERT linkage editor control statement 

description of 146-147 

example of 149 
INTEGER items 

padding 137 

storage representation of 185 



196 



internal sequence number 

example of 100 

specifying 54 

use in traceback map 111, 113 
interruption code 

(see also exception code) 

imprecise 113 

precise 113 
ISN (see internal sequence number) 



job 

defined 12 
naming a 25 
priority 28 

processing, examples in 173-178 
relationship to JOB statement 12 
termination 27-28 
time limit assignment 28-29 
job control language 
description of 12 
processing, examples of 13 
programming considerations 129-130 
job control statements 
DD statement 37-52 
delimiter statement 12,22 
examples of 173-178,19-20 
EXEC statement 30-37 
format of 22 
JOB statement 24-30 
null statement 12, 22 
PROC statement 88-89 
rules for continuing 23 
syntax of 23-24 
job output writer 28 
job scheduler 

description of 11 
JOB statement 

description of 24-30,12 
examples of 25 
format of 25 
functions of 26-27 
restriction in use of 81 
summary of 24-25 
job step 
compile 

cataloged procedures 89 

description of 53-57 

output from 99-107 
defined 12 
description of 12 
example of job control 

statements 174-175 
link edit 

cataloged procedures 89 

description of 58-62,64 

output from 108-109 
load module 

cataloged procedures 90 

description of 67-72 

output from 111-117 
loader 

cataloged procedures 90 

description of 63-66 

output from 110 
naming a 33 



priority 35-36 

relationship to EXEC statement 12 

time limit assignment 35 
job stream 

input, defined 11 
JOBLIB DD statement 

concatenating a data set with 42 

contrasted with SYSLIB DD statement 67 

example of 173-174,60 

restrictions 81 

retrieving a library with 16 
jobname, parameter in JOB statement 

description of 25 

function of 26 



KEEP, DISP subparameter 

contrasted with CATLG subparameter 21 

description of 45 
key, record 124 
keyword parameters 23 



in BUFOFF subparameter 51 
label 

data set 47-48 
reference 110 
statement 104-106 
label map (see compiler map or map, 

compiler) 
LABEL parameter 

to define an ASCII data set 68 
description of 47-48 
function of 40 
language translators 11-12 
large core storage (see hierarchy support) 
LC compiler option 53 
LCS (see hierarchy support) 
LET linkage editor option 58 

use in overlay programs 148 
LET loader option 63-64 
library, automatic call 60, 61 
library 

description of 15-16 
FORTRAN 

asynchronous input/output 

considerations 122 
error correction for mathematical 

routines 166-169 
in link edit job step 61-62 
programming considerations 130-131 
restrictions with extended error 
handling facility 161 
relationship to partitioned data 

set 70,15 
storing load module into 59 
subprograms 

affected by automatic precision 
increase 139 
SYS1. FORTLIB 16 

use of NCAL linkage editor option 59 
library functions 136 
detaching 126 
aliases 126 



Index 197 



LIBRARY statement 

description of 61-62 

example of 61, 64 
line printing, specifying 53 
LINECNT compiler option 53 
link edit job step 

cataloged procedures describing 8 9 

example of job control statements 13 

input to, description of 58-63,64 

output from, description of 108-109 

primary input 60 

secondary input 61-62 

summary of output 16 
link pack area queue 65 
linkage conventions 

coding, example of 181-183 

summary of 180 
linkage editor 

cataloged procedures 89 

contrasted with loader 58 

control statements 

description of 61-6 2 
in overlay programs 146-148 
example of 149-153 

map 58 

name of 58 

options 58-59 

overlay processing 141-145 
example of output 148-153 

processing 64 
linkage editor data sets 

description of 59-61,14 
linkage editor options 

description of 58-59 

example of output from 109 

overlay options 148 
LIST compiler option 53 

example of output 102-103 

use in tracing errors 113,114 
LIST linkage editor option 59 

example of overlay output 153 

use in overlay program 148 
list-directed input/output 127 
listing 

compiler cross reference 102,54 

linkage editor cross 
reference 108-109,58 

object module 102-103, 53 

source module 100, 53 

structured source 104, 54 
literal constants 

affected by automatic precision 
increase 139 

restriction 133 
LKED, as a name in cataloged 

procedures 85, 89 
LOAD (see OBJECT compiler option) 
load module execution job step 

cataloged procedures describing 90 

example of job control statements 13 

input to, description of 67-72 

messages 

error code diagnostics 111 

operator 115-116 

program interrupt 113-116 

output from, description of 111-117 

summary of output 16 



load module 

called from library 67 

cataloged procedures 90 

defined 12 

description of 67 

length of 108,109 

map 108-110, 63 

marking for execution 63-64 

restrictions 133 

retrieving from a library 60 

storing into a library 59 
load module data sets 

description of 67-72,14-15 

summary 68 
LOADER, as a name for the loader 

program 63 
loader 

cataloged procedures 90 

contrasted with linkage editor 58 

name of 63 

options 63-65 

storage allocation 64 
loader data sets 

description of 65-66,15 

summary of 66 
loader job step 

cataloged procedures describing 90 

input to, description of 63-66 

output from, description of 110 
loader options 63-65 
Logical IF statement 127 
LOGICAL items 

padding 137 

storage representation of 188 
logical operators 127 
loop, optimization of 128 
LR (label reference) 110 
LRECL subparameter 

default values of 

for compiler data sets 57 
for load module data sets 72 

description of 50 

example of 50 

relationship to BLKSIZE subparameter 50 



M 

to identify machine code control 
characters 49-50,77 
magnetic tape 
data set 68 
ASCII 68 

creating, example in 69 
DEN subparameter 51 
device 

BLKSIZE values for 73 
summary of types 189 
volume 

record length restriction 133 
main storage 

allocating through SIZE option 54 
map 

compiler 

affected by automatic precision 

increase 140 
description of 105-106 
example of 104 



198 



specifying through MAP option 54 
linkage editor 

description of 108 
example of 109 

output from overlay program 153 
specifying through MAP option 58 
loader 63 
MAP compiler option 54 

example of output 104 
MAP linkage editor option 58 



r> /~>n +- r n o +■ o/^ 



?ith compiler option 



110 



contrasted tfith loader option 

example of output 109 

overlay program output 148 
MAP loader option 63 

contrasted with MAP linkage editor 
opt x on xx \j 

description of 110 

example of 110 
map, traceback (see traceback map) 
master record 124 
MAX, as a SIZE option value 54 
member, partitioned data set 70-72,15 
messages 

compiler 101,99 

diagnostic 100,101 

FLAG compiler option to obtain 55 

informative 99,100 

linkage editor 108,109 

load module 111-116 
summary of 111 

operator 115-116 

program interrupt 113-116,170 

system, use of MSGLEVEL parameter 27 
MFT (see Multiprogramming with a Fixed 

Number of Tasks) 
MOD, as a DISP subparameter 45 
module 

load 12 

object 12 

source 12 
MSGCLASS parameter 

description of 28 

example of 28 

function of 26 
MSGLEVEL parameter 

description of 27 

example of 27 

function of 26 
Multiprogramming with a Fixed Number of 
Tasks 

description of 11 

partitions in 11 

requesting a dump under 115 
Multiprogramming with a Variable Number of 
Tasks 

description of 11 

REGION parameter 29,36 

regions in 11 

requesting a dump under 115 
MVT (see Multiprogramming with a Variable 
Number of Tasks) 



NAME compiler option 54 

name field, in job control statements 23 



names 

compiler handling of 127 

device class, summary of 46 

namt? rrsmr*! i e* - ootion to soeeifv 54 

qualified 19 
NCAL linkage editor option 59 
NEW, as a DISP subparameter 21 

considerations with direct access 
programming 125 

contrasted with OLD subparameter 21 
nine-track tape, density of 51 
NOALC (see ALC compiler option) 
NOANSF (see ANSF) 
NODECK (see DECK compiler option) 
NODUMP (see DUMP compiler option) 
NOEDIT (see FORMAT compiler option) 
NOFMT (see FORMAT compiler option) 
NOFORMAT (see FORMAT compiler option) 
NOGOSTMT (see GOSTMT compiler option) 
NOID (see GOSTMT compiler option) 
NOLET (see LET loader option) 
NOLIST (see LIST compiler option) 
NOLOAD (see OBJECT compiler option) 
NOMAP compiler option (see MAP compiler 

option) 
NOOBJ (see OBJECT compiler option) 
NOOBJECT (see OBJECT compiler option) 
NOOPT (see OPTIMIZE compiler option) 
NOOPTIMIZE (see OPTIMIZE compiler option) 
NOPRINT (see PRINT loader option) 
NORES (see RES loader option) 
NOSOURCE (see SOURCE compiler option) 
NOXREF (see XREF compiler option) 
NR, in compiler map 106 
null job control statement 12 

function of 22 



OBJ (see OBJECT compiler option) 
OBJECT compiler option 53 
object module 

considerations with OPTIMIZE option 127 

defined 11 

specifying 53 
object module deck 

DECK option to specify 53 

description of 106-107 

example of 107 
object module listing 

example of 102-103 

description of 104-105 

LIST option to specify 53 

use in tracing errors 113,114 
OLD, as a DISP subparameter 45 

considerations with direct access 
programming 125 

contrasted with NEW subparameter 21 
operand field, in job control statement 23 
operating environment (see Multiprogramming 
with a Fixed Number of Tasks ; 
Multiprogramming with a Variable Number of 
Tasks) 
operation field, in job control 

statements 23 
operator exception code 114,116 

corrections for 170 



Index 199 



operator message 

description of 115-116 

example of 117 

summary of 111 
operators, in COND parameter of JOB 

statement 28 
OPT (see OPTIMIZE compiler option) 
OPTCD subparameter 

to define ASCII data set 68 

description of 52 

programming considerations 130 
OPTERR parameter 154 
optimization techniques 

specifying 53-54 
OPTIMIZE compiler option 53 

COMMON statement considerations 123 

example of output 104 

FORMAT option relationships 54 

programming considerations 127-129 
OPTIMIZE (1) programming 

considerations 127-128 
OPTIMIZE (2) programming 
considerations 128-129 

example of output 104 
option table 

changing entries in 158-160,156 

default values 155 

description of 154 

format of 164-165 

preface of 154,164 

specifying a user-supplied routine 159 
options 

ASCII 68 

compiler 

description of 53-56 
example of output 100,102-104 
format of 53 
summary of 56 

linkage editor 

description of 58-59 
example of output 109 

loader 

description of 63-66 
example of output 110 

PARM parameter considerations 34-35 
ORDER statement 62 
OUT, as a LABEL subparameter 48 
output 

compiler 99-107 

linkage editor 108-109 

load module 111-117 

program output 116-117 

loader 110 

summary of 16 
output class 

A for printer 55 

B for card punch 55 
output writer 28 
OVERFL subprogram 131 
overflow condition 121 
overlay 

linkage editor control 
statements 14 6-14 8 

linkage editor options 148 

output, example of 149-153 

paths 142-143 

process, description of 141-145 

program 



constructing a 146-148 

designing a 141-144 
programming considerations 125 
references 

exclusive 144 

inclusive 143 
segments 141-142 
structure 

example of 147 

tree 141-142 
OVERLAY statement 

description of 146 
example of 149 
OVLY linkage editor option 148,59 
example of output 153 



to describe compiler map variables 105 

in program interrupt message 113, 116 
padding data 134 
PAGE statement 62 
parameters 

keyword 23 

positional 23 

symbolic 88 
parentheses, use in PARM parameter 34-3 5 
PARM parameter 

description 3 4 

examples of 34-35 

function of 31 

options specified in 
compiler 53-56 
ALC option 138 
AUTODBL option 135-138 
linkage editor 58-59 

overlay options 14 8 
loader 63 

rules for continuing 34-35 
partitioned data set 

adding members to 70 

creating 70 

deleting 71,72 

description of 70-71,15 

LABEL parameter considerations 48 

relationship to library 70 

restrictions 70 

retrieving 70-71 
partitions, in MFT and VS1 control 

program 11 
PASS, AS A DISP subparameter 45-46 
paths, overlay 142-143 
PAUSE statement 

message generated by 115-116 

restriction 133 
PDS (see partitioned data set) 
PDUMP library subprogram 139 
permanent data set 

contrasted with temporary data set 21 

description of 21 
PGM parameter 

description of 33-34 

example of 33-34 

function of 31 

specifying 

compiler 53 
linkage editor 58 



200 



load module 67 
loader 63 
positional parameter 23 
pre-allocated data set 130 
precise interruption 113 
primary input, to link edit job step 60 
PRINT loader option 65 

example of output 110 
printer, BLKSIZE values for 73 
private data sets 

(see also user data sets) 

defining 21 

storing load modules into 59 
problem program 

description of 12 
PROC parameter 

description of 32-33 

function of 32-3 3 
PROC statement 

description of 88-89 

format of 88 

modifying cataloged procedures with 90 
procedure library 13 
procedure-name, parameter in EXEC statement 

(see PROC parameter) 
PROCESS statement 55 
processing program 

description of 11-12 
procstep.ddname 39 
program 

control program 11 

FORTRAN 

as a problem program 12 
restrictions in use by other 
processors 80 

naming a, through the EXEC statement 33 

processing program 11-12 

sample of a 97-98 

source program, listing of 100 
program interrupt message 

corrections for, with extended error 
handling facility 170 



UCO^LiJJCH-Ill <Ji- 






example of 116 
program options 

use of PARM parameter 34-35 
program output 116-117 

summary of 16 
program status word 114-115, 116 
program unit 

relationship to control section 108 

use in overlay structure 141-144 
program- name, parameter in EXEC statement 

(see PGM parameter) 
programmer-name, parameter in JOB statement 

description of 27 

example of 27 

function of 26 
promoting data 134-135 
protected storage, violation of 114 
protection exception code 114,116 
PRTY parameter 

description of 28 

example of 28 

function of 26 

restriction 28 
PSW (program status word) 114-115,116 
punch, card (see card punch) 



to define ASCII data set 52,68 
qualified names 19 



randomizing technique 124 
READ statement 
END= option 

to process partitioned data 
set 70-71 
FIND statement with 125 
programming considerations 129 
relationship to partitioned data set 48 
reader, card (see card reader) 
REAL items 

padding 137 
promoting 134-135 
storage representation of 186 
real mode 29-30 
RECFM subparameter 

ASCII data set considerations 76-79 
asynchronous input/output 

considerations 121 
default values of 

for compiler data sets 57 
for load module data sets 72 
description of 50 
direct-access data set 

considerations 80 
EBCDIC data set considerations 73-76 
use of 

in fixed-length records 73 
in undefined-length records 74 
in variable-length records 73 
record key 124 
record location counter 124 
records 

(see also fixed-length records, 
undefined- length records, 
variable- length records) 
BLKSIZE values for 73 
chaining of 125 

characteristics of, defining 49-52 
detail 124 
format of 50 
length of 50 
master 124 
spanned 74,76 
structure of 
ASCII 78-79 
direct-access 80 
formatted 75 
unformatted 76 
region, in MVT and VS2 control program 11 
REGION parameter 

in EXEC statement 36, 32 
in JOB statement 29,27 
SIZE compiler option relationship 132 
register 

in linkage conventions 179,180 
OPTIMIZE option considerations 128 
relocate feature 11 
relocation dictionary 106 
RES loader option 65 
return code 129,184 

compared with condition code 28 



Index 201 



RETURN statement 129 
REWIND statement 

asynchronous input/output 
considerations 71 

partitioned data set considerations 71 
RLD card 106-107 

RLSE, as a SPACE subparameter 47 
root segment 141-142 
ROUND, as a SPACE subparameter 47 



to describe compiler map variables 105 

to specify spanned records 50 
sample program 97 
save area 179-180 
SD (section definition) 110 
secondary input, to link edit job step 62 
section definition 110 
segment control word 50,73 
segment, overlay 

communication with 143-144 

OVERLAY statement to define 146 

relation origin of 142 

root segments 141-14 2 
SEP parameter 

description of 4 9 

function of 40 

programming considerations 129 
SEP subparameter in UNIT parameter 4 6 

programming considerations 130 
seguence number 

defined 14 

description of 41 

processing partitioned data sets 
with 71 
seguential data set 

creating 69 

DCB considerations for 
ASCII data sets 76-79 
EBCDIC data sets 73-76 
default values for load module 72 

description of 69,15 

retrieving 69 
serious error message, description of 101 
seven-track, density of 51 
severity code 

explanation of 16 

listing of 101 
SHR, as a DISP subparameter 45 
simulator 113-114 
SIZE compiler option 54 

REGION parameter relationships 132 
SIZE loader option 64 
SLITE subprogram 131 
SLITET subprogram 131 
sort and merge program 12 
SOURCE compiler option 53 
source module 

defined 12 

listing of 

description of 101, 100 
LIST option to specify 53 

naming 54 
SPACE parameter 

DEFINE FILE statement relationship 125 

description of 47 

function of 41 



spanned records 

description of 74 

example of 76 
special characters 

in job control language 27,34 
specification exception code 114,116 

correction for 170 
spill, array element 123 
statement function 

restrictions 132 
statistics, compiler 100 
STEPLIB DD statement 

to concatenate data sets 42 

to retrieve a user library 16 
stepname, in EXEC statement 33, 31 
STOP n statement 

message generated by 115-116 

restrictions 129 
storage 

allocation 
job 29 
job step 3 6 

dumping 131 

SIZE option 54 
storage map 

for COMMON blocks 

description of 106 
example of 107 

defined 16 
structured source listing 

(see also edited source listing) 

example of 104 

description of 105 

FORMAT option to specify 54 
subprograms 

affected by promotion of data items 135 

assembler language 
coding 181-183 
description of 179 
examples of 181-183 

entry points to 18 3 

extended error handling 
considerations 158-160,156 

OPTIMIZE option considerations 128-129 

programming considerations 130-131 

return codes 129 
subroutine 

extended-precision 131 

mathematical, error corrections 
for 166-169 

user-supplied 129 
summary of errors listing 111,112 
superscript, in job control statements 24 
supervisor, description of 11 
support, hierarchy (see hierarchy support) 
symbolic parameters 

description 88 

example of 89 

modifying cataloged procedures with 90 
synonyms, in direct-access programming 124 
SYSABEND DD statement 

contrasted with SYSUDUMP DD statement 

description of 57 

DUMP compiler option relationship 55 

requesting a dump 115,41 
SYSDA device class 14 
SYSIN DD statement 

cataloged procedure use of 89,19 



202 



default values of 57 

description of 56, 67 

FT05F001 DD statement relationship 67 

function of 14 

as a qualified name 19 
SYSLIB DD statement 

CALL option relationship 63 

contrasted to JOBLIB DD statement 67 

description of 59 

function of 14 

SYSl. FORTLIB library relationship 59 
SYSLIN DD statement 

default values of 57 

description of 

for compiler data set 56 

for linkage editor data set 59 

for loader data set 65 

function of 14 

OBJECT compiler option relationships 53 
SYSLMOD DD statement 

cataloged procedure use of 89 

creating a user library with 16 

description of 59-60 

function of 14 

as the name of a load module 67 
SYSLOUT DD statement 

cataloged procedure use of 90 

description of 65 

function of 14 

PRINT loader option relationship 65 
SYSOUT parameter 

description of 44-45 

function of 40 
SYSPRINT DD statement 

default values of 57 

description of 55 

function of 14 
SYSPUNCH DD statement 

DECK compiler option relationship 53 

default values of 57 

description of 55 

function of 14 
SYSSQ device class 14 
system data set 14-15 
system library 16 
system messages 

specifying through MSGLEVEL 
parameter 27 
system storage requirements 131-132 
SYSUDUMP DD statement 

contrasted with SYSABEND DD 
statement 57 

description of 57 

DUMP compiler option relationship 55 

requesting a dump 115,41 
SYSUT1 DD statement 

default values of 57 

description of 

for compiler data sets 56 

for linkage editor data sets 60 

FORMAT compiler option relationship 54 

function of 14 
SYSUT2 DD statement 

(see also SYSUT1 DD statement) 

default values of 57 

description of 56 

XREF compiler option relationship 54 



SYSl. FORTLIB 

as automatic call library 61 

as partitioned data set 15 

SYSLIB DD statement relationship 59 
SYS1.LINKLIB 42,16 

SYSLMOD DD statement relationship 59 
SYS1.PROCLIB 81,16 



to indicate track overflow 50 
table of names (compiler map) 54 
tape, magnetic (see magnetic tape) 
temporary data set 

contrasted with permanent data set 21 

creating a 69 

description of 21 

as a partitioned data set 69 
termination message 101, 27 
time limit 

assigning to a job 28-29 

assigning to a job step 36 

suppressing 29 
TIME parameter 

in EXEC statement 

description of 36 
function of 32 

in JOB statement 

description of 28-29 
function of 26 
traceback map 

description of 111 

example of 112 

use of 112-114 

requesting printing of 160 
requesting suppressing of 159 
track overflow 

for direct-access data sets 80 

restrictions 121, 122 

use of 74, 50 
translators, language 11-12 
TRK 

as a SPACE subparameter 47 
TRTCH subparameter 51-52 
TXT card 106-107 



u 

to specify undefined-length records 
description of 50,74 
example of 75 
UNCATLG, as a DISP subparameter 45 
undefined-length records 
BLKSIZE values for 73 
DCB considerations 

for ASCII data sets 76,78 
for EBCDIC data sets 74-75 
description of 49 
underscore, use in job control language 24 
unformatted input/output 

affected by automatic precision 
increase 140 
unformatted records 

DCB considerations 74,76 



Index 203 



direct-access data sets 80 

input/output list relationship 74 
UNIT parameter 

description of 46-47 

examples of 4 6 

device types 189 

function of 41 
unit record 

data sets 68-69 

devices, summary of 18 9 
unit types 18 9 
user data sets 

(see also private data sets) 

defining 21,15 
user library 

description of 16 
user-supplied subroutines 129 
utility program 

description of 12 



V 

to specify variable-length records 
description of 50,73 
example of 70 
variable items 

dumping 131 

promotion of 134 

retrieving address of 183 

storage representation of 185-188 
variable, associated 16 
variable-length records 

BLKSIZE values for 73 

DCB considerations 

for ASCII data sets 76,78 
for EBCDIC data sets 73,75 

description of 50 

examples of 75 
virtual mode 29-30 
virtual storage 11 
volume, defined 14 



VOLUME parameter 

description of 43 
function of 39 

VS1 11 

VS2 11 



WAIT statement 121 
warning message 101 
WRITE statement 

relationship to partitioned data set 



XCAL linkage editor option 148 
XF external function 105 
XR external reference 10 5 
XREF compiler option 54 

example of output 102 
XREF linkage editor option 58 

contrasted with XREF compiler 
option 108 

example of output 109 

use in overlay program 148,153 



as a severity code 101,16 

4 as a severity code 101,16 

5 as a data set reference number 67, 20 

6 as a data set reference number 67,20 

7 as a data set reference number 67 

8 as a severity code 101,16 
12 as a severity code 101, 16 
16 as a severity code 101,1b 
2311 direct-access device 189 
2314 direct-access device 189 
2361 larger core storage device 29 
2400 magnetic tape device 189 



48 



204 



READER'S COMMENTS 



TITLE: IBM OS FORTRAN IV ORDER NO. SC28-6852-1 

(j-j FxtpnHprO flnrfinilpr 

Programmer's Guide 



Your comments assist us in improving the usefulness of our publications; they are an important part 
of the input used in preparing updates to the publications. All comments and suggestions become 
the property of IBM. 

Please do not use this form for technical questions about the system or for requests for additional 
publications; this only delays the response. Instead, direct your inquiries or requests to your IBM 
representative or to the IBM Branch Office serving your locality. 

Corrections or clarifications needed: 
Page Comment 



Please include your name and address in the space below if you wish a reply. 



Thank you for your cooperation. No postage necessary if mailed in the U.S.A. 



SC28-6852-1 



fold 



fold 



FIRST CLASS 
PERMIT NO. 33504 
NEW YORK, N.Y. 



BUSINESS REPLY MAIL 

NO POSTAGE NECESSARY IF MAILED IN THE UNITED STATES 



POSTAGE WILL BE PAID BY . . . 

IBM CORPORATION 
1271 Avenue of the Americas 
New York, New York 10020 




Attention: PUBLICATIONS 



O 

O 

3 
■o 



fold 



fold 



n: 



International Business Machines Corporation 

Data Processing Division 

1133 Westchester Avenue, White Plains, Nbw York 10604 

[U.S.A. only] 

IBM World Trade Corporation 

B21 United Nations Plaza, New York, New York 10017 

[International] 



SC28-6852-1 



i 
m 
3 

o 
o 

3 
■o 



13 

P 
■D 

5' 
8. 

D. 

, 5' 
c 
to 

> 
o 

00 

ft 

tn 
ro 



n: 



International Business Machines Corporation 

Data Processing Division 

1133 Westchester Avenue, White Plains, New York 10604 

(U.S.A. only) 

IBM World Trade Corporation 

821 United Nations Plaza, New York, New York 10017 

(international)