P3/COBOL Compiler Options

The P3/COBOL command-line command to compile COBOL programs into Java classes is a sub-command of the p3 command. See p3-utility for a description of the p3 command and its sub-commands, including the build command.

P3/COBOL Build Command

Syntax

$\mathsf{p3} \begin{Bmatrix} \small\mathsf{b}\\ \small\mathsf{build} \end{Bmatrix} \begin{bmatrix} \space \mathit{p3CompilerOptions} \space \end{bmatrix} \space \cdots \space \begin{Bmatrix} \mathit{sourceFilePath}\\ \mathit{sourceFilePattern} \end{Bmatrix} \space \cdots$

The sourceFilePath is a batch command file (shell on *nix) specification, which may contain wild-card characters and environment variable substitutions, for example. Remember that if the file path specified contains space characters on Windows, you must quote the argument to prevent it from being interpreted as split at each space character.

As an alternative, you may specify a quoted string that will be processed as a source_file_pattern. The source file pattern is an environment-independent (same on Windows/UNIX/Linux/Mac OS X) pattern for locating target files. It is similar to a shell or command-line wild card path, but more flexible. In addition to the * and ? characters you may use ** to indicate an arbitrary number of directory levels of any name. Thus src/**/*.cbl will select any file with a .cbl extension at any level at or below the src directory, for example.

As a convenience, regardless of technique for selecting the files, p3 compile will exclude (as COBOL) any files that have a .java extension and will deposit the copies of those files in the configured generated-Java source directory. It will then compile both the generated Java classes and the copied Java source files into Java class files. Any Java source class files copied in this manner will, therefore, have a package name consistent with the directory structure of generated source directory to which they are copied, not their original location.

The options are described in detail below, and the javac_option_string is a string of any legal javac compiler options. p3 b will pass-through any javac options to the javac compiler when it is invoked to compile the generated P3/COBOL classes into byte-code class files.

Compiler Options

all-files-optional

<all-files-optional>false</all-files-optional>

This option, if set to true, causes the compiler to consider all files to have the OPTIONAL property set, even when not explicitly specified in the SELECT clause.

The possible values for boolean are:

binary-allocation

<binary-allocation>NORMALIZED</binary-allocation>

This option determines the number of bytes allocated for binary-usage data items.

The possible values for binaryAllocationStrategy are:

byte-order

<byte-order>BIG_ENDIAN</byte-order>

This option determines the order of bytes within binary or national usage data items whose binary layout must be determined at compile-time. If such a determination must be made, this option value is used, and the byte order is fixed at the value of this option. If the byte order is fixed, the runtime configuration file must either specify no byte order preference, or must specify the same byte order as this compiler configuration. It is recommended that this option be set only if required for interaction with native-code external libraries, as it limits the portability of the Java classes generated. Note that if the fast-initialize option is chosen, and any binary or national item uses the VALUE clause and a subsequent INITIALIZE statement is used for that item, it will require the byte order at runtime to match the chosen or default byte order at compile time.

The possible values for byteOrderEnumeration are:

classpath

<classpath>/path/to/dir-or-file</classpath>

This option, if present, provides a javaClasspathString specification that is passed on to the built-in javac compiler. It is then used as if javac were invoked separately with the classpath specified.

The possible values for javaClasspathString is any valid Java classpath specification. There is no default value for this option.

commented-cobol-comments

<commented-cobol-comments>false</commented-cobol-comments>

Directs the compiler to retain and generate as Java comments any COBOL comments from the program(s) if and only if this option is true. In some cases, even when this option is set to true, the COBOL statement comments will be abbreviated or omitted.

The possible values for boolean are:

commented-cobol-statements

<commented-cobol-statements>false</commented-cobol-statements>

Directs the compiler to retain and generate as Java comments the COBOL statements from the program(s) if and only if this option is true. In some cases, even when this option is set to true, the COBOL statements will be abbreviated or omitted.

The possible values for boolean are:

computational-default

<computational-default>BINARY</computational-default>

Directs the compiler to use the indicated binary USAGE whenever USAGE IS COMPUTATIONAL is used or implied. For example, if RM/COBOL default behavior is desired, you may specify COMP_7 as the computational-default. This will cause unpacked decimal with a trailing combined sign to be the COMPUTATIONAL default.

The possible values for computationalDefaultUsageEnumeration are:

config-file

<config-file>compiler.p3c</config-file>

This option specifies the pathString to be used for an XML compiler configuration file.

The possible values for pathString is any valid file pathname. The default is compiler.p3c in the Current Working Directory, if not specified.

congruent-assignment-optimization

<congruent-assignment-optimization>true</congruent-assignment-optimization>

This option controls optimization of moving items to an item or items with the equivalent usage/picture. If the two items are "congruent", the move can often be done avoiding accessors and unnecessary size testing and truncation. The default value for boolean is true.

copy-directories

<copy-directories>cpy</copy-directories>

This and the following (if present) option’s value determines the directory paths used by the compiler for locating and loading COPY books. The paths searched to satisfy a COPY reference in the source program are:

1. If a LIBRARY is specified in source, that path is searched for. If the name matches a library name, that directory will be the focus of the search.
2. If not found or no LIBRARY, the current working directory is searched.
3. If not found, any directories specified in this (the copyDirectoryStringList) option are searched in the order they are specified.
4. If not found, an error is indicated.

The possible values for copyDirectoryStringList are a space-separated list of legal directory pathnames. The default is the Current Working Directory. The copyDirectoryStringList may contain replacement markers. See Replacement Markers for more information.

copy-extensions

<copy-extensions>cpy</copy-extensions>

This option’s copyExtensionsStringList determines the extension names used by the compiler for locating and loading COPY books. The name specified in the COPY directive is first used with no additional extension. If not found, the name is tried with each extension specified in this option in the order specified. This process is repeated in each of the locations referred to in the copy-directives option above.

The possible values for copyExtensionsStringList are a space-separated list of extension names. The default value is "cpy".

copy-libraries

<copy-libraries>
    <library name="p3lib" path="copies/lib/p3"/>
</copy-libraries>

This option allows the specification of named copybook library directories. It encloses <library> elements each of which designates a copy library path and name attribute. See the <copy-directories> option for details.

data-element-caching

<data-element-caching>NUMERIC_COHERENT_WS</data-element-caching>

This option directs the compiler to generate optimized code to implement a specific type of data element caching. When this option is set to NUMERIC_COHERENT_WS if possible any numeric item in working storage will be cached in native Java type containers. This means that when a cached item is accessed a check is made to see if the item has been previously retrieved and cached. If so, the cached Java field is used to retrieve the value. If the option is set to NUMERIC_COHERENT, the caching takes place for linkage section items also. NONE specifies no caching is to be done. Redefined and renamed items are never cached, nor are filler items and externals. If the debug-level is other than NEVER or the generate-all-accessors option is specified as true the default for caching is NONE.

The possible values for cachingStrategyEnumeration are:

data-package

<data-package>data.*</data-package>

Directs the compiler to use the value of this option to determine the package name for generated Java data classes. If the directory name(s) comprising this value do not exist, the compiler will automatically create them.

The possible values for dataPackageNamePattern is any valid Java package name. At any point in the package name a * may be used to indicate the package segment name (flattened program name) corresponding the top-level program being compiled. This permits placing data packages under the name of the program they pertain to. If the dataPackageNamePattern does not contain a *, the compiler will attempt to generate a single data package will all group data classes in the current compilation. Identical group classes with the same name will be combined, if possible, to reduce the total number of data classes needed by the application. This combined data class is much slower than when program-qualified packages are used and it is recommended that it not be used for development and testing builds of an application. Further more, it must be used with either the command-line compiler or an Ant script-based build script within the Eclipse IDE.

debug

<debug>false</debug>

Directs the compiler to produce Java source and classes that can be controlled by the P3/COBOL debugger. This option also controls the insertion of source line/column information in the generated Java allowing that information to be provided in the traceback in case of abnormal termination. It is recommended that this option be specified during development and testing except when maximum performance is desired. This option is deprecated and the <debug-level> option offers greater control of the debug information and should be used instead.

The possible values for boolean are:

debug-kind

<debug-kind>CONCISE</debug-kind>

Determines the kind of generated debug code. At compile time the type of debug information included in the generated program is determined by the debugKindEnumeration.

The possible values for debugKindEnumeration are:

debug-level

<debug-level>NEVER</debug-level>

Determines the level of generated debug code. At runtime, the code is activated as determined by the debugLevelEnumeration.

The possible values for debugLevelEnumeration are:

debug-lines

<debug-lines>false</debug-lines>

This option directs the compiler to treat lines with “D” or “d” in the indicator column as normal COBOL code to be compiled if and only if this option is true.

The possible values for boolean are:

debug-source-base-directory

<debug-source-base-directory>/path/to/debug-source-base-directory</debug-source-base-directory>

This option allows the specification of a common base directory to which all source files will be referenced by the embedded debug information in Java class files. This is done automatically when compilation is done by the IDE Eclipse builder. In that case, the common base directory for all source files is the Project directory. If this option is used in command-line mode, all file locations will be made relative to the specified source base directory, provided the file's absolute path has a left-hand path that exactly matches the base directory, and the device is the Same for both. If omitted, the default is to make file references relative to the current directory at the time of compilation (i.e., equivalent to "."). If not omitted, but its value is the empty string, absolute paths will be used.

decimal-type

<decimal-type>DECIMAL</decimal-type>

This option directs the compiler to generate code using the specified decimal data type for any fixed-point decimal quantities. The default is to use the built-in decimal type which is optimized for this COBOL. In some cases, the optimizations of the Java built-in BigDecimal type can yield better performance and should be chosen.

For debugging and special performance optimization purposes the CheckedDecimal type should be chosen. It is a subclass of BigDecimal with additional tools and options added for diagnostic purposes and should not normally be used in production programs.

The possible values for decimalTypeEnumeration are:

default-binary-delimiter-rm

<default-binary-delimiter-rm>false</default-binary-delimiter-rm>

This option directs the compiler to generate code that uses the RM/COBOL protocol for delimiting binary sequential files if and only if this option is true. This option allows the RM/COBOL RECOVER2 utility to be used to reconstruct indexed files in the P3/COBOL environment. It may also be used when direct access to sequential files in the RM format is desired.

The possible values for boolean are:

default-delimiting

<default-delimiting>BINARY</default-delimiting>

This option directs the compiler to use the indicated record delimiting technique as the default for SEQUENTIAL organization files. This option is overridden by an explicit specification of the delimiting technique in the program.

The possible values for defaultDelimitingEnumeration are:

default-lock-delay

<default-lock-delay>100</default-lock-delay>

Directs the compiler to use the indicated delay in milliseconds as the time between each attempt to acquire a record lock, should such a wait be required. Typically lock attempts are queued and this timeout does not apply.

The possible value for delayTime is any positive integer. The default value is 100 (milliseconds). If frequent record locks are expected, especially when remote programs are contending with local programs, this option value may be reduced to prevent starvation of the remote user.

default-locking

<default-locking>NONE</default-locking>

Directs the compiler to use the indicated locking mode as the default for shared files. This option is overridden if locking mode is specified in the program. The setting for this to achieve RM/COBOL default behavior is AUTOMATIC.

The possible values for defaultLockingEnumeration are:

default-select-mode

<default-select-mode>DYNAMIC</default-select-mode>

Determines the file selection mode in the absence of explicit phrases in the SELECT clause.

The possible values for defaultSelectModeEnumeration are:

default-sharing

<default-sharing>NOT_SPECIFIED</default-sharing>

Directs the compiler to use the indicated default sharing mode in the event no sharing mode is specified in the program.

The possible values for defaultSharingEnumeration are:

destination-directory

<destination-directory>bin</destination-directory>

This option’s value determines the directory path used by the compiler for generating the Java class files for program and data packages.

The possible values for path are any legal directory pathnames that can be written by the current user. If this option is not specified and the source-directory option is specified, the generated classes will be placed in that directory. If source-directory is not specified, this option will default to "bin".

diagnostic-levels

<diagnostic-levels>123/WARNING</diagnostic-levels>

Provides error level alterations. The levelAlterationList consists of a space-separated list of error numbers and error levels. The number is separated from the error level by a "/" character (e.g., "123/WARNING 456/CAUTION"). For errors with an original level of WARNING and below, any new level may be assigned. For errors of level ERROR and above, you may assign a higher, but not lower, level. The error level choices are as described below for <diagnostic-threshold>.

diagnostic-threshold

<diagnostic-threshold>WARNING</diagnostic-threshold>

Directs the compiler to suppress (filter out) reporting of errors with a level less severe than the specified level. Note that the errors still may affect the compiler and/or the generated Java code, even though they are not reported to the user.

The possible values for diagnosticThresholdEnumeration are:

dialect

<dialect>NONE</dialect>

Indicates to the compiler that the program source code may be assumed by the compiler to conform to the COBOL dialect specified. This option also determines the default values of several individual configuration options.

For other options in this section, the default values shown for individual options assume a dialect of NONE is in effect. For other settings of the dialect option, the effect on the default is noted below. Note that when a specific dialect is set, the compiler may or may not

The possible values for dialectEnumeration are:

When the RM or RM_COBOL dialect is specified, the following default options apply:

When the MF dialect is specified, the following default options apply:

When the OSVS dialect is specified, the following default options apply:

When the IBM dialect is specified, the following default options apply:

When the XOPEN dialect is specified, the following default options apply:

When the VSC2 dialect is specified, the following default options apply:

When the COBOL_2000 or COBOL_2000_DML dialect is specified, the following default options apply:

When the NET_COBOL dialect is specified, the following default options apply:

When the HP dialect is specified, the following default options apply:

When the COBOL_400 dialect is specified, the following default options apply:

When the ANSI85 dialect is specified, the following default options apply:

When the ISO2002 or ISO2014 dialect is specified, the following default options apply:

When the P3 dialect is specified, the following default options apply:

direct-storage-access-optimization

<direct-storage-access-optimization>true</direct-storage-access-optimization>

Directs the compiler to optimize access to stored items by using inline, direct manipulation of storage without using generated accessors if and only if this option is true. The most likely use case for setting this to false is when the readability of the generated code supersedes the potential performance improvements of this option, for example, if the generated code is intended to be used as a human-modifiable Java base.

The possible values for boolean are:

display-numeric-conversion

<display-numeric-conversion>false</display-numeric-conversion>

Forces the compiler to convert display-usage numerics in an ANSI mode DISPLAY statement to a digits-only, leading-signed, representation (without decimal place) if and only if this option is true. If set to false, all items will be displayed in a type-appropriate string representation.

The possible values for boolean are:

embedded-sql

<embedded-sql>false</embedded-sql>

Directs the compiler to process embedded SQL (ESQL) and generate calls to a built-in library that uses JDBC to carry out the specified actions if and only if this option is true. If set to true, the database-associations runtime option should be used to configure the connection to the database to be used.

The possible values for boolean are:

event-type-filter

<event-type-filter>BANNER ERROR DIAGNOSTIC</event-type-filter>

Selects which compiler event categories are reported. The value is a space-separated list of eventType names.

The possible values for eventType are:

The default is BANNER ERROR DIAGNOSTIC.

fast-initialize

<fast-initialize>false</fast-initialize>

Directs the compiler to generate optimized code for data initialization if and only if this option is true. If this option is true and the program(s) contain one or more initialized binary items, the byte order determined by the compiler will determine the byte order that must be used at runtime. It is recommended that this option be left set to the default value unless the optimization is required, as it will restrict portability of the generated Java classes.

The possible values for boolean are:

floating-point-rounding

<floating-point-rounding>NONE</floating-point-rounding>

This option determines how the presence of floating point operands affects the rounding of the other operands and result in arithmetic expressions.

The possible values for floatingPointRoundingEnumeration are:

force-default-charset

<force-default-charset>false</force-default-charset>

The compiler will force the default charset choice for the source files if and only if this option is true. If false (the default), the source charset will be automatically determined by sampling the source file(s), and the default will be chosen only if no charset can be determined by the automatic sampling. See the source-charset-default option for more detail.

The possible values for boolean are:

fractional-exponentiation-type

<fractional-exponentiation-type>DOUBLE</fractional-exponentiation-type>

This option determines the method of performing exponentiation when exponent is a fixed-point decimal fraction.

The possible values for fractionalExponentiationTypeEnumeration are:

generate-all-accessors

<generate-all-accessors>false</generate-all-accessors>

Directs the compiler to generate all possible data access methods regardless of use by the compiled program(s). If debug mode or is selected, this option defaults to true to enable all declared items to be accessed by the debugger. If explicitly set to false, only variables used by the program will be accessible in debug mode and only accessors that are used by the program logic will be generated.

The possible values for boolean are:

generate-all-data-annotations

<generate-all-data-annotations>[true|false]</generate-all-data-annotations>

Directs the compiler to generate data annotations for every data item regardless of other option settings if this option is set to true. If set to false, directs the compiler to only annotate data items that also have generated accessors regardless of any other option settings. By default, the compiler will decide when items should have data annotations based on the other options set.

The possible values for boolean are:

generate-class-files

<generate-class-files>true</generate-class-files>

Directs the compiler to generate the Java class files ("*.class") for the COBOL program(s) if and only if this option is true. This option is typically used in IDE-based projects when it is desirable to have the Java Builder compile the generated "*.java" files into "*.class" files rather than the P3/COBOL compiler.

The possible values for boolean are:

generate-entry-classes

<generate-entry-classes>true</generate-entry-classes>

Directs the compiler to generate Java class files for ENTRY statements if and only if this option is true.

The possible values for boolean are:

generate-filler-annotations

<generate-filler-annotations>false</generate-filler-annotations>

Directs the compiler to generate data annotations for every FILLER data item regardless of other option settings if this option is set to true. If set to false, directs the compiler to only annotate data items that also have generated accessors or need annotation for some other reason regardless of any other option settings. By default, the compiler will not generate filler data annotations unless they are required by some other selected option or program action (e.g., debugging or import/export).

The possible values for boolean are:

generate-java-beans

<generate-java-beans>false</generate-java-beans>

Directs the compiler to generate the necessary accessor methods to allow top-level group classes to be used as Java Beans if and only if this option is true. This allows other Java-based tools and frameworks to access COBOL data structures as standard Java Beans without consideration of the COBOL nature of the data.

The possible values for boolean are:

generate-javadocs

<generate-javadocs>true</generate-javadocs>

Directs the compiler to generate Javadocs commentary as needed if and only if this option is true.

The possible values for boolean are:

generate-program-classes

<generate-program-classes>true</generate-program-classes>

Directs the compiler to generate the Java classes for the COBOL program(s) if and only if this option is true. This option is typically not used for application development and testing.

The possible values for boolean are:

generate-synchronized-accessors

<generate-synchronized-accessors>false</generate-synchronized-accessors>

Directs the compiler to generate synchronized data accessors for this program if and only if this option is true. If set to true, non-COBOL concurrent threads can access COBOL data in a thread-safe manner provided they synchronize their accesses on the run unit in the same way. Utility methods are provided in DataUtil to accomplish this. There is a measurable performance penalty for enabling this option, so it should not be used unless thread-safe data access is required by the application.

The possible values for boolean are:

help

--help

This option causes command line help information to be written to standard output.

histogram

<histogram>false</histogram>

Directs the compiler to generate histogram events for the COBOL program(s) if and only if this option is true. See also the histogram-smallest-bucket option below.

The possible values for boolean are:

histogram-smallest-bucket

<histogram-smallest-bucket>STATEMENT</histogram-smallest-bucket>

Specifies the smallest collection bucket size to be supported by the generated code. This smaller than or equal to the histogram-bucket-size runtime option(s) to be used.

The possible values for smallest-bucket-at-runtime in smallest to largest order are:

ignore-uncaught-arithmetic-overflow

<ignore-uncaught-arithmetic-overflow>true</ignore-uncaught-arithmetic-overflow>

This option, if set to false, causes the compiler to generate code that catches OVERFLOW conditions when neither ON OVERFLOW nor NOT ON OVERFLOW clauses are present in a statement in which they are allowed and arithmetic overflow conditions may occur and subsequently terminate execution of the program.

The possible values for boolean are:

implicit-recursion

<implicit-recursion>false</implicit-recursion>

Directs the compiler to assume an implicit IS RECURSIVE aspect for all programs. This has the effect of causing the return address and base address of LINKAGE SECTION items, if any, to be saved upon entry to each program and restored upon exit. This option interacts with the <sticky-linkage> option.

The possible values for boolean are:

integer-arithmetic-safety

<integer-arithmetic-safety>SAFE</integer-arithmetic-safety>

🎯 Allows the compiler to generate unsafe long (64-bit) arithmetic if the user believes that there are no operations on integers that would exceed the capacity of a 64-bit item. SAFE is the default, causing the compiler to promote to BigInteger any operation that could exceed the algebraic maximum or minimum value containable in a 64-bit long, thus avoiding any potential loss of significance. When narrowing conversions of integer values are performed, this mode ensures that the narrowed value can be properly stored with decimal trucation if needed. UNSAFE allows the compiler to assume that the result of any integer operation on int or long operands can be held in a long without loss of significance. It CHECKED directs the compiler to make the UNSAFE assumption, but also to check to make sure that the assumption is true for each operation that would potentially lose significance. If such a loss is detected, it is treated as a catchable SIZE error similar to division by 0. It is recommended that either SAFE or CHECKED be selected, unless compute performance is critical, a large number of long integer multiplications, additions, or subtractions are performed, and the user is very sure that no significance-losing operations would be performed.

The results of operations involving int operands that could overflow that data type are always automatically promoted by the compiler to long within arithmetic expressions regardless of the setting of this option.

The possible values for longArithmeticSafetyEnumeration are:

This option was formerly named <long-arithmetic-safety>. That name is deprecated but remains accepted for compatibility with existing configuration files. If both names are present, the deprecated <long-arithmetic-safety> value takes precedence over <integer-arithmetic-safety>. Use <integer-arithmetic-safety> in new configuration; the deprecated name may be removed in a future release. The deprecated name is accepted only as a configuration element and has no command-line equivalent.

java-arguments

<java-arguments>-cp mylib.jar</java-arguments>

This option specifies a javac argument string to be passed through to the built-in javac compiler. If this option is specified on a command line (rather than in a configuration file), a # must be used as the first character of its value to distiguish it from a subsequent P3/COBOL compiler option. If present, this guard character will be removed by the P3/COBOL compiler and will not be passed on to the java compiler. For passing multiple java compiler arguments from the command line using this option, the shell must also be prevented from interpreting a space as a command argument separator, so the entire argument string value should be escaped by some means dictated by the shell being used. In most cases, this can be accomplished by quoting the arguments (including the guard #), or by escaping the space separators with \\. The guarding and escaping are unnecessary if this option is provided in the configuration file.

The possible value for compilerJavaArguments is any valid javac argument list, with the above modifications if necessary.

java-properties

<java-properties>NORMALIZED</java-properties>

This option specifies list of java properties to be set during compilation. The list takes the form of space-separated name=value pairs providing the value(s) for the property(ies) to be set.

java-source-base-directory

<java-source-base-directory>src-generated</java-source-base-directory>

This option specifies the path of a directory containing Java source packages to be compiled into "*.class" files with any generated Java source files. If not specified, the default is to compile any Java files in the current directory.

list-output

<list-output>false</list-output>

Directs the compiler to generate a COBOL listing file if and only if this option is true. The generated listing file may be subsequently compiled by P3/COBOL and, if so, will produce exactly the same generated Java as the original COBOL program file with the original COPY files. The listing file is completely self-contained (i.e., has no COPY references to other files). The storage map, if any, will also be written to the effective listing output file (see list-output-file option).

The possible values for boolean are:

listeners

<listeners>
    <listener name="custom" value="com.example.MyCompilerListener"/>
</listeners>

This option allows the specification of named compiler listener classes. It encloses <listener> elements each of which designates a listener name and value attribute. The value is a fully qualified Java class name that implements a P3/COBOL listener interface and provides a public no-argument constructor.

This option may only be used within the compiler configuration file; there is no command-line equivalent. There is no default value for this option.

listing-output-file

<listing-output-file>*</listing-output-file>

This option’s value determines the file/directory path used by the compiler for generating the listing components. A * may be included instead of the file name, in which case the listing file, if any, will be written to a file whose name is the same as the source file with an extension of .lst. If this option is specified and includes directories that do not exist at the time the listing(s) is written, the missing directories will be created if possible. If this option is not specified and one or more of the listing components are requested, they will be written as if * alone was specified for this option.

The possible values for listingOutputFilePathPattern are any legal file pathname (with the above modification if present).

literal-compaction-optimization

<literal-compaction-optimization>true</literal-compaction-optimization>

Directs the compiler to compact literal storage and optimize frequently used literals for speed if and only if this option is true. The default value for boolean is true.

locking-behavior

<locking-behavior>STANDARD</locking-behavior>

Directs the compiler to use the indicated locking behavior when reading shared files. STANDARD indicates that the locking behavior specified in the 201x draft standard should be used. RM indicates that RM/COBOL default locking behavior should be used. RM also causes the indexed file access to be performed in a manner equivalent to RM/COBOL indexed file handling, including some undocumented and non-standard behavior (e.g., no loss of currency after AT END if read direction changed). This option should be set for maximum RM/COBOL runtime compatibility.

The possible values for lockingBehaviorEnumeration are:

max-init-count

<max-init-count>1000</max-init-count>

Directs the compiler to break initialization of very large groups such that no single initialization method initializes more than the indicated number of elementary items. This option may be necessary if the program contains very large (more than 10,000 items) initialized groups.

The possible values for count are any positive non-zero integer. The default value is 1000.

maximum-decimal-digits

<maximum-decimal-digits>31</maximum-decimal-digits>

Directs the compiler to limit the maximum number of decimal digits that may be specified in a numeric or numeric-edited picture to the indicated number. This option does not affect the precision of arithmetic results or intermediate values, but may affect the value of the runtime configuration option, maximum-decimal-precision, that may be safely set.

The possible values for the maximumDecimalDigits are the integers 1 through 64 inclusive. The default value is 31.

native-charset

<native-charset>NATIVE</native-charset>

The value of this option specifies the Java Charset encoder/decoder to use when converting to/from Strings and COBOL alphanumeric items. These conversions occur when processing the VALUE clause of a data definition entry or 88-condition, when ACCEPTing an alphanumeric value from a console, and when DISPLAYing an alphanumeric value upon a console. No conversion takes place for national and national-edited items, as these items can represent all characters in the Unicode set. The default value (NATIVE) causes all conversions to assume the native codeset. If option is set here, it must be compatible with the corresponding runtime option specified when the program is run.

The possible values for charsetEnumeration are:

overwrite

<overwrite>true</overwrite>

Directs the compiler to overwrite existing generated Java source files if and only if this option is true. This option may only be specified in the compiler configuration file; there is no command-line equivalent.

The possible values for boolean are:

perform-adhesion

<perform-adhesion>NONE</perform-adhesion>

Determines the persistence of PERFORM statement return points. This option interacts with the perform-type option to determine the overall behavior of PERFORM. The default for this option is determined by the dialect chosen unless explicitly overridden.

The possible values for performAdhesionEnumeration are:

perform-type

<perform-type>STACKED</perform-type>

Determines the type of PERFORM statement return behavior. This option interacts with the perform-adhesion option to determine the overall behavior of PERFORM. The default for this option is determined by the dialect chosen unless overriden explicitly.

The possible values for performTypeEnumeration are:

pointer-math

<pointer-math>false</pointer-math>

Directs the compiler to allow subtraction of POINTER items that are pointing to the same 01-level group item if and only if this option is true. This permits the relative displacement of items to be determined by a running program. This is sometimes done by COBOL programs originally running in IBM mainframe computer environments and is supported by P3/COBOL for compatibility. A preferred technique to accomplish this is to use the intrinsic functions or special register extensions to determine the length and offset of data items directly.

The possible values for boolean are:

pointer-size

<pointer-size>8</pointer-size>

This option value determines the number of significant bytes allocated in POINTER data items. The number of bytes of storage allocated for the POINTER item must be large enough to accommodate the runtime environment’s pointer size, but may be larger. If larger, the additional bytes reserved in memory are ignored. If no pointers refer to directly allocated memory (see the allocate-all-direct runtime option), the pointer size is only required to be large enough to identify all active pointers. In this case, any size over 2 will likely satisfy this constraint.

In 32-bit environments the pointer size may be safely set to any number 4 or greater. The default value of 8 is sufficient for both 32 and 64-bit environments. Note that the number of bytes reserved in memory for pointers may be forced to a number greater than or equal to this option size by use of the binary allocation override in the USAGE clause (e.g., USAGE IS POINTER(16) would cause allocation of the associated POINTER item as 16 bytes even if this option is set to 8).

The possible values for size are any positive non-zero integer. The default value is 8.

program-package

<program-package>programs</program-package>

Directs the compiler to use the value of this option as the package name for generated Java program classes. If the directory name(s) comprising this value do not exist, the compiler will create them.

The possible values for packageNamePattern are any valid Java package name. At any point in the package name a * may be used to indicate the package segment name (flattened program name) corresponding the top-level program being compiled.

replacement-word-wrapping

<replacement-word-wrapping>false</replacement-word-wrapping>

The value of this option determines if the preprocessor should ensure space separators before and after replacement text specified as a COBOL word (rather than pseudo text).

The possible values for boolean are:

rm-compatible-comp1

<rm-compatible-comp1>false</rm-compatible-comp1>

Directs the compiler to use the RM/COBOL semantics and format for COMPUTATIONAL-1 if and only if this option is true. This causes COMPUTATIONAL-1 items to use 16-bit binary rather than single-precision floating point representation.

The possible values for boolean are:

sign-default-leading

<sign-default-leading>false</sign-default-leading>

Directs the compiler to assume a default configuration of SIGN IS LEADING for DISPLAY-usage items if and only if this option is true.

The possible values for boolean are:

sign-default-separate

<sign-default-separate>false</sign-default-separate>

Directs the compiler to assume a default configuration of SIGN IS ... SEPARATE for DISPLAY-usage items if and only if this option is true.

The possible values for boolean are:

source-charset-default

<source-charset-default>ISO_8859_1</source-charset-default>

The compiler will use the charset specified by this option if automatic charset determination fails or if the force-default-charset option is true.

The possible values for charsetEnumeration are:

source-directory

<source-directory>src-java</source-directory>

This option’s value determines the directory path used by the compiler for generating the Java source for program and data packages.

The possible values for path are any legal directory pathnames that can be written by the current user. If this option is not specified, the generate source classes will be placed in a temporary directory and discarded after the actual Java class files are written.

source-format

<source-format>FIXED72</source-format>

Determines the initial setting for the COBOL source format. The initial setting may be changed at any point in the source program(s) or COPY modules by use of compiler directives (e.g., >>imp set format FIXED72). Other custom formats and settings may be specified by the SET compiler directive.

The possible values for sourceFormatEnumeration are:

sticky-linkage

<sticky-linkage>DIALECT_DEFAULT</sticky-linkage>

Directs the compiler to use a particular behavior for LINKAGE SECTION items.

The possible values for linkageEnumeration are:

storage-map

<storage-map>false</storage-map>

Directs the compiler to generate a COBOL storage allocation map if and only if this option is true. The storage map will always be written to the effective listing-output-file.

The possible values for boolean are:

synchronize-size

<synchronize-size>0</synchronize-size>

Specifies the alignment size in bytes used when SYNCHRONIZED is specified. The default is 0. This option is accepted in the compiler configuration file. The corresponding command-line form is the internal option --x-synchronize-size and is not documented here.

tab-size

<tab-size>4</tab-size>

The value of this option determines the number of space characters represented by any tab characters found in the COBOL source program. This will normally only affect program behavior when tabs are included within alphanumeric literals since COBOL treats multiple spaces elsewhere as equivalent to a single space. It is recommended that tab characters not be used in COBOL source, as they may unpredictably affect program behavior as outlined.

The possible values for size are any non-zero positive integer. The default value is 4.

terminal-accept-display-mode

<terminal-accept-display-mode>false</terminal-accept-display-mode>

Directs the compiler consider ACCEPT and DISPLAY statements to be RM/COBOL style terminal operations if possible. This is equivalent to specifying CONSOLE IS CRT in the environment division of the program(s).

The possible values for boolean are:

truncate-binary

<truncate-binary>true</truncate-binary>

Directs the compiler to assume binary data items should be truncated according to the picture provided. This option interacts with the runtime option of the same name in that the runtime option will have no effect if this option is specified as false, since the code to truncate the binary items will not have been generated.

The possible values for boolean are:

version

--version

Directs the compiler to write the compiler version information to the standard output file.

when-compiled-date-format

<when-compiled-date-format>hh.mm.ssMMM dd, yyyy</when-compiled-date-format>

Determines the format of the alphanumeric data item returned when the "WHEN-COMPILED" special register is referenced in the program(s).

The possible values for dateFormat are any legal strings according to the SimpleDateFormat Java class. The default value is hh.mm.ssMMM dd, yyyy.

words-to-unreserve

<words-to-unreserve>TAB</words-to-unreserve>

The value of this option specifies COBOL words that would normally be reserved words but should be “unreserved” and allowed to be used as user-defined words in the source program. Note that any such unreserved words may no longer be used as keywords and, to the extent that the unreserved word is essential, the features or language elements that normally rely on such keywords may no longer be recognized.

The possible values for the reservedWordList are a space-separated list of valid COBOL keywords. The default is that no words are unreserved. If a word is immediately preceded by a minus - character, the following word is re-reserved if it is unreserved by the chosen dialect, for example.

wrap-control-threshold

<wrap-control-threshold>500</wrap-control-threshold>

Directs the compiler to wrap the control-flow cases when more than the integer number of sections/paragraphs are present. The default should be sufficient for almost every program encountered, but might have to be adjusted for programs with an unusually large number of paragraphs.

The possible values for integer are any non-zero positive integer. The default is 500 paragraphs/sections.

wrapping-threshold

<wrapping-threshold>500</wrapping-threshold>

Directs the compiler to wrap lists of statements in anonymous classes when they contain more statements than the number specified by this option. A slight performance penalty is incurred when this happens, but it substatially eliminates the Java limitation of 65,535 byte-codes per method as a limitation on COBOL program size. The default should be sufficient for almost every program encountered, but might have to be adjusted for particularly unusual programs.

The possible values for integer are any non-zero positive integer. The default is 500 lines (250 when compiling for debug).

xml-declaration-is-standard

<xml-declaration-is-standard>true</xml-declaration-is-standard>

Directs the compiler to specify a standard XML declaration when the XML GENERATE statement is used. The declaration would then include the encoding which, if an alphanumeric target is specified, would specify the actual encoding of the bytes generated. If set to false, the encoding is only included if the target is usage national (i.e., UTF-16), otherwise the encoding is not specified in the declaration. This setting is believed to be consistent with the Micro Focus COBOL standard behavior in this case.

The possible values for boolean are:

Z

-Z

Can be used to terminate the parsed options on the command line. This is only necessary if the last parsed option allows a list of values to be specified.