COBOL Compiler Options and Compile JCL

COBOL COMPILATION

The VS COBOL II compiler prepares a VS COBOL II source program for execution by producing a machine-language object module. This object module contains the actual machine language which implements or carries out the instructions specified in the COBOL source program. (The object module produced by the compiler must be processed by the linkage editor before the program is actually ready for execution.)

A single invocation of the compiler can compile an individual COBOL source program or a sequence of two or more separate source programs. The object programs which result from compiling more than one source program at a time may be link-edited into a single load module or into two or more separate load modules.

The VS COBOL II compiler provides several additional services while compiling a program. These include:

producing a source listing tayloring the content of the source listing (i.e., to include a sorted cross-

reference of data-names, a map of the DATA DIVISION, a listing of the machine-language instructions that were generated, etc.).

setting literal delimiters selecting a reserved word list processing COPY, BASIS, and REPLACE statements offering options to control object code generation, object code execution,

and the compilers use of virtual storage producing debugging information at run time providing user-exits

ADV:

This is a COBOL compiler option.

Format: ADV NOADV Abbreviations: None IBM-default: ADV

ADV, which conforms to the ANSI standard, requests that the compiler add 1 byte to the record length to account for the printer control character when WRITE with the ADVANCING option is used.

NOADV implies that the record length has already been adjusted to account for the printer control character.

QUOTE/APOST:


Format: QUOTE APOST Abbreviations: Q IBM-default: QUOTE

QUOTE, which conforms to the ANSI standard, specifies that the double quotation mark () is to be the delimiter character for non-numeric literals.

APOST specifies that the single quote mark or apostrophe () is to be the delimiter character for non-numeric literals.

AWO:


Format: AWO NOAWO Abbreviations: NOAWO IBM-default: None

AWO specifies that, for any file in the program which is physical sequential with blocked V-mode records, the APPLY WRITE-ONLY clause be in effect (even if this clause is not specified in the program).

BUFSIZE:


Format: BUFSIZE(nnnn) (nnnK)

where nnnn is a decimal number no less than 256 nnnK is a decimal number in 1K (1024) increments

Abbreviations: BUF IBM-default: 4096

BUFSIZE specifies the amount of main storage to be allocated to each compiler work file buffer.

Generally, a large buffer size will improve compiler performance; however, BUFSIZE cannot exceed the track capacity for the device being used nor can it exceed the maximum allowed by data management services.

If the SIZE option is specified along with BUFSIZE, the amount of storage allocated to buffers is included in the amount of storage available for compilation as specified by the SIZE option.

CMPR2:


Format: CMPR2 NOCMPR2 Abbreviations: None IBM-default: NOCMPR2

CMPR2 requests that generated object code be compatible with code generated by VS COBOL II Release 2.

NOCMPR2 requests that generated object code conform to the ANSI 85 standard (i.e., as implemented by VS COBOL II Release 3, which, in some instances, is incompatible with Release 2).

CMPR2 (which forces on the FLAGMIG option) can be used to assist in the migration of programs written under Release 2 to the 85 standard (i.e., to the Release 3 level).

See Release 2 Compatibility And Migration in the VS COBOL II Release 3 APPLICATION PROGRAMMING GUIDE for more information (including a list of elements that are CMPR2 sensitive and a description of their behavior under CMPR2 and NOCMPR2).

COMPILE:


Format: COMPILE NOCOMPILE NOCOMPILE(W) (E) (S)

Abbreviations: C NOC IBM-default: NOCOMPILE(S)

COMPILE forces a full compilation even when serious errors are detected. All diagnostics and object code will be generated (even though the object code should not be executed if serious errors are detected).

NOCOMPILE requests a syntax check only. Diagnostic messages (but no object code) are produced. When NOCOMPILE is specified, the following options have no effect (even though listed among the options in effect) because no object code is generated:

DECK FDUMP LIST OBJECT OFFSET OPTIMIZE SSRANGE TEST NOCOMPILE(W), NOCOMPILE(E), and NOCOMPILE(S) -for level W (warning), level E (error), and level S (severe error) diagnostics, respectively- request a conditional full

compilation (i.e., diagnostics and object code), with object code generation (but not diagnostics) to stop when an error of the level specified (or higher) is encountered.

*** Compiler Options ***

There are 4 ways in which options may be passed to the compiler, listed below in order of precedence:

Installation defaults that are fixed for your installation PROCESS (or CBL) statements in the source code JCL parameter Installation defaults that are not fixed

Fixed installation defaults may not be overridden. Installation defaults that are not fixed may be overridden by either PROCESS/CBL statements and/or by JCL parameters. If conflicting or mutually exclusive options are specified on both PROCESS/CBL statements and via a JCL parm, then the PROCESS/CBL statement takes precedence.

For a list of the default options in effect for your installation, run a compile without specifying any options and look at the list of compiler options in effect produced as part of the normal compiler printout. (For a list of the fixed defaults, see your manager or technical support staff.)

Note: The default value shown in the individual option descriptions

is the IBM-supplied default shipped with the product (which may have been changed by your installation).

PROCESS statements must appear before the IDENTIFICATION DIVISION header and are formatted as shown below:

PROCESS option1,option2,....

IDENTIFICATION DIVISION.

CBL may be used as a synonym for PROCESS. PROCESS can start in columns 1 through 66 (or 8 through 66 if a sequence field is placed in columns 1 through 6). CBL can start in 1 through 70 (or 8 through 70 if a sequence field is used). One or more blanks must separate PROCESS/CBL from the first option; options must not contain embedded blanks and must be separated be a comma or a blank. Options may not be continued; however, multiple PROCESS/CBL statements may be used.

PROCESS/CBL statements may be inhibited by your installation. In this case, PROCESS/CBL statements in the source code will be flagged with a COBOL error message.

If conflicting versions of the same option (i.e., DECK and NODECK, NAME and NONAME, etc.) are specified at the same level of precedence (say, for example, via a JCL parameter), then the last one specified takes precedence. For example, specifying:

PARM=(DECK,NAME,NODECK)

would result in NODECK being used as the active option.

The table below shows how mutually exclusive options (i.e., LIST and OFFSET, RENT and NORES, etc.). are handled when specified at the same level of precedence.

OPTION OPTION OPTION SPECIFIED IGNORED FORCED ON* ---------------- --------------- ----------------- TEST FDUMP NOFDUMP NOOBJECT OBJECT NORES RES OPTIMIZE NOOPTIMIZE

RENT NORES RES

DYNAM NORES RES

OFFSET LIST NOLIST

CMPR2 FLAGSTD NOFLAGSTD FLAGSAA NOFLAGSAA DBCS NODBCS

NOCMPR2 FLAGMIG NOFLAGMIG

WORD FLAGSTD NOFLAGSTD

FLAGSTD FLAGSAA NOFLAGSAA FLAGMIG NOFLAGMIG DBCS NODBCS

FLAGSAA FLAGMIG NOFLAGMIG

DBCS FLAGMIG NOFLAGMIG

*Unless in conflict with a fixed installation default option.

As an example, suppose FLAGSTD is set up as a non-fixed system default and that WORD is specified as an option via a JCL parm. Then the options in effect would be WORD and NOFLAGSTD (because WORD, at a higher level of precedence than the non-fixed default FLAGSTD, would force NOFLAGSTD on).

Shown below are the option settings required to conform to the 1985 ANSI COBOL Standards:

ADV NOCMPR2 NODBCS DYNAM NOFASTSRT NOFLAGMIG NOFLAGSAA FLAGSTD LIB NAME(ALIAS) or NAME(NOALIAS)

NONUMBER

NUMPROC(NOPFD) or NUMPROC(MIG) QUOTE RESIDENT NOSEQUENCE TRUNC(STD)

NOWORD

ZWB

The chart below shows what you can do with compiler options by grouping them into various activities and, within each activity, listing the specific task associated with each option.

Compiler

Activity/Task Option ------------------------------------------------------ --------- Control source listing and diagnostics:

Produce system dump at compile time.............. DUMP Set severity level of diagnostics................ FLAG Identify Release 2/Release 3 incompatibilities... FLAGMIG Flag non-SAA compatible elements................. FLAGSAA Flag specified non-standard elements............. FLAGSTD Select output language........................... LANGUAGE Set number lines per page for compiler output.... LINECOUNT Produce list of generated code................... LIST Produce DATA DIVISION map........................ MAP Select line number processing.................... NUMBER Produce condensed PROCEDURE DIVISION listing..... OFFSET Specify sequence number processing............... SEQUENCE Produce source listing........................... SOURCE Select spacing within source listing............. SPACE Send diagnostics to SYSTERM dd statement......... TERMINAL

Produce verb cross-reference..................... VBREF Produce sorted cross-reference................... XREF

Provide debugging information at run time:

Produce formatted dump for abends................ FDUMP Setup for batch/interactive debugging............ TEST

Set literal delimiters:

Set apostrophe as non-numeric delimiter.......... APOST Set quote mark as non-numeric delimiter.......... QUOTE Recognize shift codes for DBCS................... DBCS

Control object code output:

Set diagnostic severity to stop compilation...... COMPILE Produce object code as 80-column card images..... DECK Generate link-edit NAME for each object module... NAME Output object code to SYSLIN dd statement........ OBJECT

Optimize object code:

Specify APPLY WRITE-ONLY clause.................. AWO Allow sort product to perform I/O................ FASTSRT Request optimized object code.................... OPTIMIZE

Control object code generation and execution:

Provide byte for printer control character....... ADV Generate Release 2 compatible code............... CMPR2 Restrict dynamic storage to 16-meg line.......... DATA Specify dynamic CALL............................. DYNAM Set DISPLAY output ddname........................ OUTDD Specify invalid sign processing.................. NUMPROC Request reentrant object code.................... RENT Request Library Management Feature............... RESIDENT Check subscripts/indexes/ref. mod. expressions... SSRANGE Set binary field truncation...................... TRUNC Remove sign from DISPLAY fields for comparisons.. ZWB

Control compilers use of virtual storage:

Set buffer size.................................. BUFSIZE Set amount of storage available for compilation.. SIZE

Miscellaneous:

Select reserved word list........................ WORD Process COPY, BASIS, and REPLACE statements...... LIB Provide User-exits............................... EXIT

Some compiler options are specified with sub-parameters. These sub-

parameters are specified in parentheses (with multiple sub- parameters, when applicable, generally separated by a comma) immediately following the option to which they apply (with no intervening or embedded blanks). As examples:

DATA(24) SIZE(MAX) FLAG(W,E)

DATA:


Format: DATA(24) (31)

Abbreviations: None IBM-default: DATA(31) For a program compiled with the RENT option which is to be executed under XA, the DATA option specifies whether dynamic storage (for data areas such as WORKING STORAGE, file buffers, etc.) is to be acquired from below the 16-meg line or from unrestricted storage.

DATA(24) specifies that dynamic storage areas are to be allocated from storage below the 16-meg line. DATA(31) specifies that dynamic storage areas are to be

allocated from unrestricted storage (i.e., either above or below the 16-meg line).

DATA(24) should be used for programs running under XA in 31-bit addressing mode that are passing data parameters to programs in 24-bit addressing mode. Otherwise, the called program may not be able to address the data being passed.

DBCS:


Format: DBCS NODBCS Abbreviations: None IBM-default: NODBCS

DBCS instructs the compiler to recognize X0E and X0F as shift codes for the double byte portion of a non-numeric literal. (The double byte portion is syntax checked; the literal remains in the alphanumeric category.)

If either CMPR2 or FLAGSTD is specified, DBCS is ignored.

NODBCS conforms to the ANSI standard.

DECK:


Format: DECK NODECK Abbreviations: D NOD IBM-default: NODECK

DECK requests that object code be produced in the form of 80- column card images and output to the SYSPUNCH dd statement.

DUMP:


Format: DUMP NODUMP Abbreviations: DU NODU IBM-default: NODUMP

DUMP requests that a dump be produced whenever the compiler abnormally terminates. This option is normally used by IBM personnel in order to diagnose bugs in the compiler itself. When DUMP is specified, a SYSABEND, SYSUDUMP, or SYSMDUMP dd statement should be included in the compile JCL.

NODUMP provides a limited set of diagnostic information when the compiler abnormally terminates. This includes a description of the error, the compiler execution phase at the time of the abend, the line number of the COBOL statement being processed when the error occured, and the contents of the general purpose registers.

DYNAM:


Format: DYNAM NODYNAM Abbreviations: DYN NODYN IBM-default: NODYNAM

DYNAM specifies that separately compiled programs invoked through the CAll literal statement (i.e., a CALL statement where the program to be called is specifed in the form of a literal) are to be loaded dynamically at run time.

NODYNAM implies that programs invoked through the CALL literal statement will be statically linked into the run-unit prior to execution.

EXIT:


Format: EXIT(xparm) NOEXIT Abbreviations: EX NOEX IBM-default: NOEXIT

EXIT, depending upon the sub-parameters specified, instructs the compiler to:

accept source input from a user-supplied exit module (rather than from the file defined with the SYSIN dd statement)

accept copy input from a user-supplied exit module (rather than from the file defined with the SYSLIB dd statement)

pass printer output to a user-supplied exit module (rather than to the file defined with the SYSPRINT dd statement)

The xparm sub-parameters (separated by a comma) must be specified by choosing one option from each of the 3 pairs of options shown below:

INEXIT(instring,inmod) or NOINEXIT LIBEXIT(libstring,libmod) or NOLIBEXIT PRTEXIT(prtstring,prtmod) or NOPRTEXIT

where inmod, libmod, and prtmod are, respectively, the names of the user-supplied load modules to be used in place of SYSIN, SYSLIB, and SYSPRINT

and instring, libstring, and prtmod are optional character strings of up to 64 characters (enclosed in apostrophes) that are to be passsed to the

corresponding user-supplied load module

INEXIT, LIBEXIT, and PRTEXIT may be abbreviated as INEX, LIBEX, and PRTX, respectively.

EXIT may only be specified via a JCL parm or as an installation default (i.e., it may not be specified in a PROCESS/CBL statement).

FASTSRT:


Format: FASTSRT NOFASTSRT Abbreviations: FSRT NOFSRT IBM-default: NOFASTSRT

FASTSRT specifies that, during an internal sort operation, IBM DFSORT (or an equivalent sort product) is to perform the I/O operations on sort input and output files (i.e., SORT USING and GIVING). This option may improve internal sort performance.

NOFASTSRT, which is the ANSI standard, specifies that COBOL is to perform the I/O operations on these files.

FDUMP:


Format: FDUMP NOFDUMP Abbreviations: FDU NOFDU IBM-default: NOFDUMP

FDUMP requests that a formatted dump be produced at run time when execution ends in an abnormal termination.

When FDUMP is specified:

the run time execution JCL should include a SYSDBOUT dd statement for FDUMP output

if NUMBER is also specified, the sequence fields in columns 1 through 6 must be numeric

the size of the object module is increased (because statement number and data description tables are included as part of the object code)

No formatted dump will be produced if the NOSTAE run time option is used or if any other program in the run-unit was compiled with TEST.

FLAG:


Format: FLAG(a) NOFLAG

(a,b) where a and b are specified as I, W, E, S, or U Abbreviations: F NOF IBM-default: FLAG(I)

FLAG(a) directs the compiler to produce diagnostic messages for errors of severity level a or above at the end of the source listing.

FLAG(a,b) directs the compiler to produce diagnostic messages for errors of severity level a or above at the end of the source listing and to also place diagnostic messages for errors of severity level b and above directly in the source lising (i.e., directly after the statement in error). FLAG(a,b) has no meaning unless the SOURCE option is also specified.

NOFLAG directs the compiler to suppress error flagging.

The levels of severity for diagnostic messages are shown below:

I Informational (Return Code=0) W Warning (Return Code=4) E Error (Return Code=8) S Severe (Return Code=12) U Unrecoverable (Return Code=16)

FLAGMIG:


Format: FLAGMIG NOFLAGMIG Abbreviations: None IBM-default: NOFLAGMIG

FLAGMIG requests that the compiler identify language elements that may be implemented differently in Release 2 than in Release 3 (which conforms to the 85 ANSI standard).

NOFLAGMIG conforms to the ANSI standard.

FLAGMIG is intended to be used, in conjunction with CMPR2 (which forces on FLAGMIG), to aid in the migration of programs written under VS COBOL II Release 2 to the Release 3 level (i.e., to the 85 standard). See CMPR2 for more information.

FLAGSAA:


Format: FLAGSAA NOFLAGSAA Abbreviations: None IBM-default: NOFLAGSAA

FLAGSAA requests that the compiler identify (by flagging with a warning message) language elements that are not Systems Application Architecture (SAA) compatible. This will identify program elements that may restrict program portability across IBM systems.

NOFLAGSAA conforms to the ANSI standard.

The NOCMPR2 compiler option must be in effect in order to use FLAGSAA and the FLAGSTD option can not be used. If FLAGSTD and FLAGSAA are both specified along with NOCMPR2, FLAGSAA is ignored.

FLAGSTD:


Format: FLAGSTD(s) NOFLAGSTD (smm) (smm,o) (s,o)

where s is specified as M, I, or H in order to set the level or subset of Standard COBOL that is to be considered as conforming

mm is specified (as a single character or a combination of any two) as D, N, or S to set the optional modules to be included in the subset

o is specified as O to indicate that obsolete language elements are to be flagged

Abbreviations: None IBM-default: NOFLAGSTD

FLAGSTD is designed to provide information (via flagging) about the type of COBOL elements included in the source program. Based on the way in which the subparameters are coded, this can include flagging for non-conforming, non-standard, and/or obsolete language elements.

NOCMPR2 and the standard set of reserved words must be in effect in order to use FLAGSTD.

The sub-parameters are further described below:

For s: M specifies that language elements not from

the minimum subset are to be flagged (i.e., as non-conforming standard)

I specifies that language elements not from

the minimum or intermediate subset are to

be flagged (i.e., as non-conforming standard)

H specifies that language elements offered as

as IBM extension are to be flagged (i.e., as non-conforming non-standard)

------------

For mm: D specifies that elements from Debug module level 1 are not flagged (i.e., as non- conforming standard)

N specifies that elements from Segmentation

module level 1 are not flagged (i.e., as non-conforming standard)

S specifies that elements from Segmentation

module level 2 are not flagged (i.e., as non-conforming standard) (Note: N is a subset of S.)

For o: O specifies that obsolete language elements are to be flagged (i.e., as obsolete)

Specified elements are flagged with an informational message that:

Identifies the clause, statement, or header that contains the element as well as the source program line number and column.

Identifies the subset or optional module to which the element belongs. Identifies the element as non-conforming standard, non- conforming

non-standard, or obsolete. (A language element that is both obsolete and non-conforming is flagged as obsolete only.)

Flagging is suppressed whenever an error (diagnostic level E or higher) is detected.

*** JCL ***

Sample JCL required to invoke the compiler appears below, followed by a description of each dd statement required. This is followed by several examples (showing required JCL and selected options).

Sample compiler JCL:

//JS10 EXEC PGM=IGYCRCTL, Compiler Program Name // PARM=(options) Optional Parms //STEPLIB DD DSN=SYS1.COB2COMP,DISP=SHR PDS Containing Compiler //SYSLIB DD DSN=cpylib,DISP=SHR Copy Member Library //SYSPRINT DD SYSOUT=* Printed Output //SYSTERM DD SYSOUT=* Diagnostic Messages //SYSUT1 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT2 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT3 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT4 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT5 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT6 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT7 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSLIN DD DSN=&&OBJMOD,DISP=(MOD,PASS), Object Module Output // UNIT=SYSDA,SPACE=(subparms) //SYSIN DD * Source Program Input source program...

/* Explanation of Compiler JCL:

PARM: JCL parameter used to pass options to the compiler. (See

descriptions below.)

STEPLIB DD:

Partitioned data set containing the executable form of the compiler. (This may be installation dependent.)

SYSLIB DD:

Partitioned data set containing copy members. Required if programs to be compiled contain any COPY or BASIS statements.

SYSPRINT DD:

Provides a definition of the data set that receives printed output from the compiler. This includes the source listing, diagnostic messages, etc. Must have RECFM=F or FB. BLKSIZE can be any permissable value for the output device (up to 32760) that is a multiple of 133.

SYSTERM DD:

Provides definition of a second data set on which diagnostic messages are to be output. Only required when the TERMINAL compiler option is specified. Must have RECFM=F or FB. BLKSIZE can be any permissable value for the output device (up to 32670) that is a multiple of 81.

SYSUT1-SYSUT7:

Provides definitions of various compiler work files. These files must be on direct-access storage devices and must have RECFM=F or FB. BLKSIZE can be any permissable value for the output device (up to 32760) that is a multiple of 80.

SYSLIN DD:

Provides a definition of the output data set that is used for the object module. Must have RECFM=F or FB. BLKSIZE can be any permissable value for the output device (up to 32760) that is a multiple of 80.

SYSIN DD:

Provides a definition of the input data set that contains the source program(s) to be compiled. Must have RECFM=F or FB. BLKSIZE can be any permissable value for the input device (up to 32670) that is a multiple of 80.

Rather than specifying all of the required JCL shown above, you may prefer to invoke the VS COBOL II compiler by executing one of the IBM-supplied cataloged procedures for this purpose (i.e., COB2UC, COB2UCL, COB2CLG, etc.) or some other cataloged procedure provided by your systems programming or technical support staff. (Check with your manager or technical support staff for direction on which cataloged procedure to use.)

Examples of the JCL required to invoke the compiler (and selected options) are shown and described below:

//JS10 EXEC PGM=IGYCRCTL, Compiler Program Name // PARM=(LIST,MAP,XREF) Optional Parms //STEPLIB DD DSN=SYS1.COB2COMP,DISP=SHR PDS Containing Compiler //SYSLIB DD DSN=cpylib,DISP=SHR Copy Member Library //SYSPRINT DD SYSOUT=* Printed Output //SYSTERM DD SYSOUT=* Diagnostic Messages //SYSUT1 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT2 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT3 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT4 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT5 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT6 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSUT7 DD UNIT=SYSDA,SPACE=(subparms) Work File //SYSLIN DD DSN=&&OBJMOD,DISP=(MOD,PASS), Object Module Output

// UNIT=SYSDA,SPACE=(subparms) //SYSIN DD * Source Program Input source program...

/* The example above shows sample JCL required to execute the compiler with the following options:

LIST: to request an assembler-language listing of the generated object code

MAP: to request a DATA DIVISION map XREF: to request a sorted cross-reference listing

//JS10 EXEC PROC=COB2UC, IBM-supplied proc // PARM.COB=(OFFSET,OUTDD(DSPOUT)) Optional Parms //COB.SYSIN DD * Source Program Input source program...

/* The example above shows sample JCL required to execute the compiler via the COB2UC JCL procedure supplied by IBM. In this case, the following options are specified:

OFFSET: to request a condensed PROCEDURE DIVISION listing OUTDD: to request that execution time DISPLAY output use a

ddname of DSPOUT

LANGUAGE:


Format: LANGUAGE(xxxxxx) Abbreviations: LANG(xx) IBM-default: LANGUAGE(ENGLISH)

LANGUAGE specifies the language that will be used for compiler messages (i.e., for diagnostic messages, message summary headers, the compilation summary, and various headers and notations resulting from the use of compiler options like MAP, XREF, etc.).

The language sub-parameters that may be specified are shown below:

Sub-parameter Abbreviation Description ------------- ------------ ------------------------ ENGLISH EN Mixed case ENGLISH JAPANESE JA,JP Japanese (using Japanese

character set)

UENGLISH UE Upper-case English

Note: To use Japanese, the Japanese National Language

Feature must be installed.

If the LANGUAGE option is changed using CBL or PROCESS statements, some initial text will be printed in the language that was in effect when compiler execution began.

LIB:


Format: LIB NOLIB Abbreviations: None IBM-default: NOLIB

LIB, which conforms to the ANSI standard, instructs the compiler that it is to honor and process COPY, BASIS, and REPLACE statements.

If COPY or BASIS statements are to be processed, the compile JCL must include a dd statement for the library or libraries from which the compiler can extract the copied code (i.e., SYSLIB) as well as the SYSUT5 work file.

LINECOUNT:


Format: LINECOUNT(nn) Abbreviations: LC IBM-default: LINECOUNT(60)

LINECOUNT specifies the number of lines to be printed on each page of the compilation listing.

The nn sub-parameter must be an integer between 10 and 255. This includes 3 lines which are used for titles. If LINECOUNT is specified as LINECOUNT(50), 47 lines of source code are printed on each page of the output listing.

LINECOUNT may also be specified as LINECOUNT(0) in order to suppress pagination (i.e., no page ejects are generated within the compilation listing).

LIST:


Format: LIST NOLIST Abbreviations: None IBM-default: NOLIST

LIST requests that the compiler produce a listing of the generated machine language object code (which is produced by printing out the corresponding assembler-language source code).

LIST also provides information in the output listing about:

Global tables Literal pools WORKING-STORAGE

If compiled with the NORENT option, the WORKING-STORAGE information includes the size of WORKING-STORAGE and its

location within the object code.

LIST and OFFSET are mutually exclusive; if both are used, LIST is ignored.

The assembler-language source listing can be limited (i.e., turned on or off as required) through the use of *CONTROL LIST and *CONTROL NOLIST statements placed in the PROCEDURE DIVISION.

MAP:


Format: MAP NOMAP Abbreviations: None IBM-default: NOMAP

MAP requests that the compiler produce a listing of the items defined in the DATA DIVISION (i.e., a DATA DIVISION map).

Other MAP output includes:

Global tables Literal pools Nested program structure (and attributes)

If compiled with the NORENT option, MAP information includes the size of WORKING-STORAGE and its location within the object code.

MAP output can be limited (i.e., turned on or off as required) through the use of *CONTROL MAP and *CONTROL NOMAP statements placed in the DATA DIVISION.

NAME:


Format: NAME NAME(ALIAS) NONAME (NOALIAS)

Abbreviations: None IBM-default: NONAME

NAME and NAME(NOALIAS) request that a link-edit NAME card be generated for each object module. NAME(ALIAS) requests that, in addition to a NAME card, a link-edit ALIAS card be generated for each ENTRY statement contained in the source program.

NUMBER:


Format: NUMBER NONUMBER Abbreviations: NUM NONUM IBM-default: NONUMBER

NUMBER instructs the compiler to honor the line numbers embedded in columns 1 through 6 of each source statement. The compiler will check these columns to ensure that they contain numeric data and will sequence check them according to numeric collating sequence (as opposed to SEQUENCE, which checks them according to EBCDIC collating sequence). When a line number is found to be out of sequence, a number one greater than the number in the previous line will be assigned and sequence checking then continues with the newly assigned line number. These line numbers will also be referenced in error messages and in MAP, LIST, and XREF listings.

If NUMBER is specified and COPY statements are used, the line numbers in the source program should be coordinated with those in each referenced COPY member.

NONUMBER, which conforms to the ANSI standard, specifies that line numbers appearing in columns 1 through 6 (if any) are to be ignored. In this case, the compiler generates a line number for each line in the source program and uses these generated line numbers as references in error messages and in MAP, LIST, and XREF listings.

NUMPROC:


Format: NUMPROC(PFD) (NOPFD) (MIG)

Abbreviations: None IBM-default: NUMPROC(NOPFD)

NUMPROC(NOPFD), which conforms to the ANSI standard, specifies that the generated code is to perform invalid sign processing during run time. This will result in increased run time and a larger object module.

NUMPROC(PFD) is a performance option which specifies that invalid sign processing is not to be done. It should be used only if the data to be processed agrees exactly with the following IBM system standards:

DATA FORMAT STANDARD SIGN FORMAT ----------------- ------------------------------------------ External decimal, High-order 4 bits of the sign byte contain unsigned XF External decimal, High-order 4 bits of the sign byte contain signed overpunch XC if the number is positive or 0; XD

if the number is negative

External decimal, Separate sign byte contains character + separate sign if the number is positive or 0; - if the

number is negative

Internal decimal, Low-order 4 bits of the low-order byte unsigned contain XF Internal decimal, Low-order 4 bits of the low-order byte signed contain XC if the number is positive or 0; XD is the number is negative

NUMPROC(MIG), which conforms to the ANSI standard, is designed to aid in migrating from OS/VS COBOL to VS COBOL II. It results in the following sign processing:

preferred signs are created only for the receiving field in a MOVE statement or an arithmetic operation

no explicit sign correction is done during input operations some implicit sign correction may be done during data format

conversion operations

numeric comparisons are performed as a decimal (rather than a logical) comparison operation

OBJECT:


Format: OBJECT NOOBJECT Abbreviations: OBJ NOOBJ IBM-default: OBJECT

OBJECT requests that the generated object code be routed to the SYSLIN dd statement.

NOOBJECT and TEST are mutually exclusive; NOOBJECT is ignored if TEST is specified.

OFFSET:


Format: OFFSET NOOFFSET Abbreviations: OFF NOOFF IBM-default: NOOFFSET

OFFSET requests that the compiler produce a condensed PROCEDURE DIVISION listing. This condensed listing will contain line numbers, statement references, and the location (i.e., offset within the object code) of the first instruction generated for each statement. Other OFFSET output includes:

Global tables Literal pools

If compiled with the NORENT option, OFFSET information includes the size of WORKING-STORAGE and its location within the object code.

OFFSET and LIST are mutually exclusive; if both are used, LIST is ignored.

OPTIMIZE:


Format: OPTIMIZE NOOPTIMIZE Abbreviations: OPT NOOPT IBM-default: NOOPTIMIZE

OPTIMIZE specifies that the object code be generated for maximum efficiency. This should result in reduced run time and may also reduce the size of the object module. However, use of OPTIMIZE increases compile time.

OPTIMIZE is turned off whenever a severe error is detected.

OPTIMIZE and TEST are mutually exclusive; if TEST is specified, OPTIMIZE is ignored. Given these facts (and the additional compile time consumed by the OPTIMIZE option), it might be best to use NOOPTIMIZE while in initial program development or debugging mode.

Use of OPTIMIZE along with NUMPROC(PFD), AWO, and FASTSRT (when applicable) may result in significant run time savings.

OUTDD:


Format: OUTDD(ddname) Abbreviations: OUT IBM-default: OUTDD(SYSOUT)

OUTDD may be used to specify a ddname other than SYSOUT for run time output produced by the DISPLAY verb.

RENT:


Format: RENT NORENT Abbreviations: None IBM-default: NORENT

RENT specifies that the generated object code is to be reentrant.

NORENT specifies that the program be generated as a nonreentrant object module. (This option should not be used for CICS programs.)

Reentrant object code can be executed only in run units where all programs have been generated with the RESIDENT option. (RENT automatically forces on RESIDENT).

RENT must be specified if the program will be executed under XA in virtual storage addresses above the 16-meg line. In this case, the DATA option can be used to control whether dynamic data areas are allocated in unrestricted storage or from below the 16-meg line.

RENT automatically forces on RESIDENT and is not valid with NORESIDENT. DYNAM automatically forces on RESIDENT and is not valid with NORESIDENT.

Outlined below are the 5 valid combinations of DYNAM, RESIDENT, and RENT:

NORENT/NORES/NODYNAM

Nonreentrant code, COBOL library subroutines are statically called, CALL literal is a static call.

NORENT/RES/NODYNAM

Nonreentrant code, COBOL library subroutines are dynamically called, CALL literal is a static call.

NORENT/RES/DYNAM

Nonreentrant code, COBOL library subroutines and application subprograms are all dynamically called.

RENT/RES/NODYNAM

Reentrant code, COBOL library subroutines are dynamically called, CALL literal is a static call.

RENT/RES/DYNAM

Nonreentrant code, COBOL library subroutines and application subprograms are all dynamically called.

RESIDENT:


Format: RESIDENT NORESIDENT Abbreviations: RES NORES IBM-default: NORESIDENT

RESIDENT, which conforms to the ANSI standard, specifies that the COBOL Library Management Feature be invoked. This causes most COBOL library subroutines to be loaded dynamically at run time rather than being statically link-edited into the run unit. (This allows for application programs to automatically pick up any fixes applied to the library subroutines without having to be link-edited again.) This option requires that the VS COBOL II subroutine library be included in the JOBLIB/STEPLIB concatenation at run time.

NORESIDENT, if used when compiling each COBOL program in the run unit, specifies that the load module contain all required VS COBOL II library subroutines needed for execution. In this case, the VS COBOL II subroutine library need not be included in the JOBLIB/STEPLIB concatenation.

The RESIDENT option is automatically in effect when the DYNAM option is specified or when the source program uses CALL identifier (i.e., a CALL statement where the program to be called is specified in the form of an identifier rather a literal).

Use of the VS COBOL II Library in conjunction with an OS/VS COBOL program compiled with the RESIDENT option may result in significant performance degradation at run time.

For more information on the interaction of RESIDENT and other compiler options, see the RENT option.

SEQUENCE:


Format: SEQUECNE NOSEQUENCE Abbreviations: SEQ NOSEQ IBM-default: SEQUENCE

SEQUENCE instructs the compiler to ensure that the source program lines are in ascending EBCDIC collating sequence based on the information coded in columns 1 through 6. (Source program lines containing spaces in columns 1 through 6 are not checked.)

If NUMBER is also specified, the sequence checking is based on the numeric (rather than the EBCDIC) collating sequence.

If SEQUENCE is specified and COPY statements are used, the source program line numbers should be coordinated with the line numbers in each referenced COPY member.

NOSEQUENCE, which conforms to the ANSI standard, suppresses this sequence checking.

SIZE:


Format: SIZE(nnnn)

(nnnK) (MAX)

where nnnn is a decimal number no less than 655360 nnnK is a decimal number in 1K (1024) increments

with a minimum value of 640K MAX requests the largest block of storage

available in the user region Abbreviations: SZ IBM-default: SIZE(MAX)

SIZE specifies the amount of main storage to be made available for the compile process.

In an XA environment, SIZE(MAX) will cause the compiler to use all the storage in the user region above the 16-meg line. (Storage below the 16-meg line will be used for compiler modules that must be loaded below the line and for work file buffers.)

SIZE(MAX) should not be used if there is a need for the compiler to leave a specific amount of unused storage in the user region.

SOURCE:


Format: SOURCE NOSOURCE Abbreviations: S NOS IBM-default: SOURCE

SOURCE requests that the compiler produce a listing of the input source program (including statements brought in by COPY or PROCESS statements).

SOURCE must be specified in order to get embedded diagnostics.

SOURCE output can be limited (i.e., turned on or off as required) through the use of *CONTROL SOURCE and *CONTROL NOSOURCE statements placed in the source program.

SPACE:


Format: SPACE(1)

(2)(3)Abbreviations: None IBM-default: SPACE(1)

SPACE, which is meaningful only when SOURCE is specified, sets the (single, double, or triple) spacing to be used between the printed lines in the source code listing.

SSRANGE:


Format: SSRANGE NOSSRANGE Abbreviations: SSR NOSSR IBM-default: NOSSRANGE

SSRANGE specifies that the generated code is to check to ensure that:

the effective address generated for an index or subscript does not reference an area outside the region of the associated table

the current effective length for a variable-length item (i.e., OCCURS DEPENDING ON) is no greater than its maximum defined length

for reference modification expressions: the reference modification starting position is no less than 1 and no

greater than the current length of the subject item the reference modification length value (if specified) is no less

than 1 the reference modification starting position and length value (if

specified) do not reference an area that extends beyond the end of the subject item

If an out of range condition is detected, an error message will be written to write-to-programmer route code 11 (i.e., usually the SYSPRINT dd statement) and the program will be terminated. When running under CICS, these messages are written to a temporary storage queue.

The SSRANGE option can result in some performance degradation.

The NOSSRANGE run time option can be specified at run time in order to inhibit the range checking code generated by specifying SSRANGE as as a compile time option. In this way, the dormant range checking code can be activated at run time (i.e., to assist in resolving any unexpected errors) without having to recompile.

TERMINAL:


Format: TERMINAL NOTERMINAL Abbreviations: TERM NOTERM IBM-default: NOTERMINAL

TERMINAL requests that a copy of each diagnostic message be sent to the SYSTERM data set.

NOTERMINAL suppresses this duplicate output.

TEST:


Format: TEST NOTEST Abbreviations: TES NOTES IBM-default: NOTERMINAL

TEST requests that the compiler produce object code that can be executed with VS COBOL II batch or interactive debug.

The following options are forced on when TEST is specified:

NOFDUMP, NOOPTIMIZE, OBJECT, and RES.

If NUMBER is also specified, the sequence fields in columns 1 through 6 must be numeric.

If both the WITH DEBUGGING MODE clause and the USE FOR DEBUGGING statement are specified, then TEST is deactivated. (TEST will appear in the

options list; however, a diagnostic message will be issued to indicate that, because of the conflict, TEST is not in effect.)

Using TEST can result in significant performance degradation at run time.

TRUNC:


Format: TRUNC(STD) (OPT) (BIN)

Abbreviations: None IBM-default: TRUNC(STD)

TRUNC(STD), which conforms to the ANSI standard, specifies that, for USAGE BINARY receiving fields, the final result of an arithemetic expression or MOVE statement is truncated to the number of digits in the PICTURE clause of the BINARY receiving field.

TRUNC(OPT), which is provided as an IBM extension, is a performance option which causes the compiler to assume that data being moved to a USAGE BINARY receiving field conforms to the associated PICTURE clause. For this reason, the data will be truncated in what appears to the compiler to be the most optimal way at the time the code is being generated. This means that the truncation may be based on the number of digits in the PICTURE clause or it might be based on the actual physical size of the binary field in storage (i.e., as a halfword, fullword, or doubleword). If the data being moved has a value with a larger precision than that defined in the PICTURE clause, an unpredictable truncation of high order digits may occur.

Since the type of truncation generated for TRUNC(OPT) is unpredictable, TRUNC(OPT) should be used only if the data being moved to binary items is guaranteed not to have a value with a larger precision than that defined by the PICTURE clause for those binary items.

TRUNC(BIN), which is provided as an IBM extension, specifies that all binary items (no matter how many digits are shown in their PICTURE clause) are to be treated as a halfword, fullword, or doubleword. (The number of digits in the PICTURE clause is used only to determine the minimal binary field -i.e., halfword, fullword, doubleword- requried to store the item.) This means, once the physical size of the field is determined, that it is treated as a halfword, fullword, or doubleword both when processed as a sending field and when processed as a receiving field. In this case then, the only way to lose significant digits is to move a larger binary field to a smaller binary field (i.e., fullword to halfword, etc.).

TRUNC(BIN) should be used when there is a possibility of having more than 9 digits in a fullword or more than 4 digits in a halfword. (Specifying a PICTURE clause for a binary item with more than 4 digits forces it into a fullword. However, a halfword can contain some numbers of up to 5 decimal digits and a fullword can contain some numbers of up to 10 decimal digits.) TRUNC(BIN) should also be used when interfacing with other languages or products that have S/370 format binary data (i.e., PL/1, FORTRAN, S/370 assembler, CICS, DB2, etc.).

For the MOVE statement shown below:

MOVE 32700 TO BINFIELD1.

where BINFIELD1 is defined as:

BINFIELD1 PIC 9(4) COMP.

The result of compiling with the various binary truncation options is shown below:

Decimal Hex ------- ---- Sending Value 32700 7FBC Received Value TRUNC(STD) 2700 0A8C Received Value TRUNC(BIN) 32700 7FBC Received Value TRUNC(OPT)* 32700 7FBC or or 2700 0A8C

*Depends upon how the compiler generates the truncation logic in this particular case.

VBREF:


Format: VBREF NOVBREF Abbreviations: None IBM-default: NOVBREF

VBREF requests that the compiler produce a cross-reference showing all verb types used in the source program and the line numbers of the lines in which they appear. A summary showing how many times each verb is used is also produced.

WORD:


Format: WORD(wwww) NOWORD Abbreviations: WD NOWD IBM-default: NOWORD

WORD instructs the compiler to use an alternative reserved word table for the current compilation.

The wwww sub-parameter specifies the (up to 4) characters that are to be appended to IGYC to form the name of the reserved word table to be used. These 4 characters may not include the dollar sign ($) nor any of the character strings listed below:

ASM1 ASM2 DIAG DMAP DOPT FGEN INIT LIBO LIBR LSTR LVL0 LVL1 LVL2 LVL3 LVL8 OPTM OSCN PGEN RCTL RDPR RDSC RWT SAW SCAN SIMD XREF

NOWORD, which conforms to the ANSI standard, is a fixed default (i.e., cannot be changed by an application programmer via a JCL parm or PROCESS/CBL statement).

XREF:


Format: XREF NOXREF Abbreviations: X NOX IBM-default: NOXREF

XREF requests that the compiler produce a sorted cross-reference showing EBCDIC data-names and EBCDIC procedure names (in alphanumeric order) and the line numbers of the source lines in which they are referenced. It also includes a listing of DBCS data-names and DBCS procedure names in the same order as they appear in the source program (unless the DBCSXREF installation option is selected) as well as a section listing all the program names that are referenced in the source program and the line number in which they are defined (with external program names identified as such).

In the data-name portion of the XREF listing, line numbers preceded by the letter M indicate the data item is modified by a statement on that line. Elementary names within a group item referenced in a MOVE CORRESPONDING statement will also be included in the XREF listing.

If both XREF and SOURCE are specified, cross-reference information will also be embedded in the source listing itself (i.e., at the right hand end of the line to which it applies). This information includes line number references as well as an indication that a name is undefined (UND), duplicately defined (DUP), implicitly defined (IMP), or, if a program name,

externally defined (EXT).

XREF and NOSOURCE produce only the sorted cross-reference listing.

ZWB:


Format: ZWB NOZWB Abbreviations: None IBM-default: ZWB

ZWB, which conforms to the ANSI standard, specifies that the compiler generate code to remove the sign from a signed external decimal field when comparing such a field to an alphanumeric field.

For the two fields defined below (with their hex values shown to the right):

Hex Value

--------- FIELDA PIC S9(3) VALUE +123. F1F2C3 FIELDB PIC X(3) VALUE 123. F1F2F3

Compiling with ZWB would result in the two fields above being considered equal in value when compared; NOZWB would result in an unequal comparison.

ADV: QUOTE/APOST: AWO: BUFSIZE: CMPR2: COMPILE: IDENTIFICATION DIVISION. PARM=(DECK,NAME,NODECK) NONUMBER

DATA: DBCS: DECK: DUMP: DYNAM: EXIT: FASTSRT: FDUMP: FLAG: FLAGMIG: FLAGSAA: FLAGSTD: I specifies that language elements not from N specifies that elements from Segmentation S specifies that elements from Segmentation

STEPLIB DD: SYSLIB DD: SYSPRINT DD: SYSTERM DD: SYSUT1-SYSUT7: SYSLIN DD: SYSIN DD: LANGUAGE: Note: To use Japanese, the Japanese National Language

LIB: LINECOUNT: LIST: MAP: NAME: NUMBER: NUMPROC: OBJECT: OFFSET: OPTIMIZE: OUTDD: RENT: NORENT/NORES/NODYNAM NORENT/RES/NODYNAM NORENT/RES/DYNAM RENT/RES/NODYNAM RENT/RES/DYNAM

RESIDENT: SEQUENCE: SIZE: SOURCE: SPACE: SSRANGE: TERMINAL: TEST: TRUNC: MOVE 32700 TO BINFIELD1. BINFIELD1 PIC 9(4) COMP.

VBREF: WORD: XREF: ZWB: Hex Value

Documents

COBOL Compiler Options and Compile JCL