The following tables show the compiler options available in the XL Fortran compiler that you can enter in the configuration file, on the command line, or in the Fortran source code by using the @PROCESS compiler directive.
You can enter compiler options that start with -q, suboptions, and @PROCESS directives in either uppercase or lowercase. However, note that if you specify the -qmixed option, procedure names that you specify for the -qextern option are case-sensitive.
In general, this book uses the convention of lowercase for -q compiler options and suboptions and uppercase for @PROCESS directives. However, in the "Syntax" sections of this section and in the "Command-Line Option" column of the summary tables, we use uppercase letters in the names of -q options, suboptions, and @PROCESS directives to represent the minimum abbreviation for the keyword. For example, valid abbreviations for -qOPTimize are -qopt, -qopti, and so on.
Understanding the significance of the options you use and knowing the alternatives available can save you considerable time and effort in making your programs work correctly and efficiently.
The following options affect the compiler input at a high level. They determine which source files are processed and select case sensitivity, column sensitivity, and other global format issues.
Many of the options in Options for Compatibility change the permitted input format slightly.
Table 2. Options That Control Input to the Compiler
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -Idir | Adds a directory to the search path for include files and
.mod files. If XL Fortran calls cpp, this
option adds a directory to the search path for #include files.
Before checking the default directories for include and .mod
files, the compiler checks each directory in the search path. For
include files, this path is only used if the file name in an INCLUDE
line is not provided with an absolute path. For #include
files, refer to the cpp documentation for the details of the
-I option.
Default: The following directories are searched, in the following order:
Also, /opt/ibmcmp/xlf/8.1/include is searched; include and .mod files that are shipped with the compiler are located here. | -I Option | |
| -qci=numbers | CI(numbers) | Activates the specified INCLUDE lines.
| -qci Option |
|
-qcr -qnocr |
| Allows you to control how the compiler interprets the CR (carriage
return) character. This allows you to compile code written using a Mac
OS or DOS/Windows editor.
| -qcr Option |
|
-qdirective [=directive_list] -qnodirective [=directive_list] |
DIRECTIVE [(directive_list)] NODIRECTIVE [(directive_list)] | Specifies sequences of characters, known as trigger constants, that
identify comment lines as compiler comment directives.
| -qdirective Option |
|
-qfixed [=right_margin] |
FIXED [(right_margin)] | Indicates that the input source program is in fixed source form and
optionally specifies the maximum line length.
| -qfixed Option |
|
-qfree[={f90|ibm}] -k |
FREE[({F90| IBM})] | Indicates that the source code is in free form. The ibm and f90
suboptions specify compatibility with the free source form defined for VS
FORTRAN and Fortran 90/Fortran 95, respectively. -k and -qfree are
short forms for -qfree=f90.
| -qfree Option |
|
-qmbcs -qnombcs |
MBCS NOMBCS | Indicates to the compiler whether character literal constants, Hollerith
constants, H edit descriptors, and character string edit descriptors can
contain Multibyte Character Set (MBCS) or Unicode characters.
| -qmbcs Option |
|
-qOBJect -qNOOBJect |
OBJect NOOBJect | Specifies whether to produce an object file or to stop immediately after
checking the syntax of the source files.
| -qobject Option |
|
-U -qmixed -qnomixed |
MIXED NOMIXED | Makes the compiler sensitive to the case of letters in names.
| -U Option |
| -qsuffix={suboptions} | Specifies the source-file suffix on the command line. | -qsuffix Option |
The following options specify names or directories where the compile stores output files.
In the table, an * indicates that the option is processed by the ld command, rather than by the XL Fortran compiler; you can find more information about these options in the Mac OS X information for the ld command.
Table 3. Options That Specify the Locations of Output Files
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -d | Leaves preprocessed source files produced by cpp, instead of
deleting them.
| -d Option | |
| -o name* | Specifies a name for the output object, executable, or assembler source
file.
| -o Option | |
| -qmoddir=directory | Specifies the location for any module (.mod) files that
the compiler writes.
| -qmoddir Option |
The following options can help you to speed up the execution of your XL Fortran programs or to find areas of poor performance that can then be tuned. The most important such option is -O. In general, the other performance-related options work much better in combination with -O; some have no effect at all without -O.
Some of the options in Options for Floating-Point Processing can also improve performance, but you must use them with
care to avoid error conditions and incorrect results.
Table 4. Options for Performance Optimization
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
|
-O[level] -qoptimize[=level] -qnooptimize |
OPTimize[(level)] NOOPTimize | Specifies whether code is optimized during compilation and, if so, at
which level (0, 2, 3, 4, or 5).
| -O Option |
|
-p -pg | Sets up the object file for profiling.
| -p Option | |
|
-qalias= {[no]aryovrlp | [no]intptr| [no]pteovrlp| [no]std}...] |
ALIAS( {[NO]ARYOVRLP |[NO]INTPTR |[NO]PTEOVRLP |[NO]STD}... ) | Indicates whether a program contains certain categories of
aliasing. The compiler limits the scope of some optimizations when
there is a possibility that different names are aliases for the same storage
locations.
| -qalias Option |
|
-qalign={[no]4k| struct {=packed | natural| port}} | ALIGN( {[NO]4K | STRUCT{(packed) | (natural)| (port)}}) | Specifies the alignment of data objects in storage, which avoids
performance problems with misaligned data. Both the [no]4k and
struct options can be specified and are not mutually
exclusive. The default setting is
-qalign=no4k:struct=natural. The [no]4K option is
useful primarily in combination with logical volume I/O and disk
striping.
| -qalign Option |
| -qarch=architecture | Controls which instructions the compiler can generate. Changing
the default can improve performance but might produce code that can only be
run on specific machines. The choices are auto, g5, ppcv, and ppc970.
| -qarch Option | |
|
-qassert={ deps | nodeps | itercnt=n} | Provides information about the characteristics of the files that can help
to fine-tune optimizations.
| -qassert Option | |
|
-qcache={ auto | assoc=number | cost=cycles | level=level | line=bytes | size=Kbytes | type={C|c|D|d|I|i}}[:...] | Specifies the cache configuration for a specific execution
machine. The compiler uses this information to tune program
performance, especially for loop operations that can be structured (or
blocked) to process only the amount of data that can fit into the
data cache.
| -qcache Option | |
|
-qcompact -qnocompact |
COMPACT NOCOMPACT | Reduces optimizations that increase code size.
| -qcompact Option |
|
-qhot[=suboptions] -qnohot |
HOT[=suboptions] NOHOT | Determines whether to perform high-order transformations on loops and
array language during optimization and whether to pad array dimensions and
data objects to avoid cache misses.
| -qhot Option |
| -qipa[=suboptions] | -qnoipa | Enhances -O optimization by doing detailed analysis across
procedures (interprocedural analysis or IPA).
| -qipa Option | |
| -qpdf{1|2} | Tunes optimizations through profile-directed feedback (PDF),
where results from sample program execution are used to improve optimization
near conditional branches and in frequently executed code sections.
| -qpdf Option | |
| -qprefetch | -qnoprefetch | Indicates whether or not the prefetch instructions should be inserted
automatically by the compiler.
| -qprefetch Option | |
|
-qsmallstack -qnosmallstack |
|
Specifies that the compiler will minimize stack usage where possible.
| -qsmallstack Option |
|
-qstrict -qnostrict |
STRICT NOSTRICT | Ensures that optimizations done by the -O3, -O4, -O5, -qhot, and -qipa
options do not alter the semantics of a program.
| -qstrict Option |
|
-qstrictieeemod -qnostrictieeemod |
STRICTIEEE- MOD NOSTRICTIEEE- MOD | Specifies whether the compiler will adhere to the Fortran 2000 IEEE
arithmetic rules for the ieee_arithmetic and ieee_exceptions
intrinsic modules.
| -qstrictieeemod Option |
|
-qstrict_induction -qnostrict_induction |
|
Prevents the compiler from performing induction (loop counter) variable optimizations. These optimizations may be unsafe (may alter the semantics of your program) when there are integer overflow operations involving the induction variables.
| -qstrict_induction Option |
| -qthreaded | Specifies that the compiler should generate thread-safe code. This is turned on by default for the xlf_r, xlf90_r, and xlf95_r commands. | -qthreaded Option | |
| -qtune=implementation | Tunes instruction selection, scheduling, and other
implementation-dependent performance enhancements for a specific
implementation of a hardware architecture. The following settings are
valid: auto, g5, ppc970.
| -qtune Option | |
|
-qunroll [=auto | yes] -qnounroll |
| Specifies whether the compiler is allowed to automatically unroll
DO loops.
| -qunroll Option |
|
-qunwind -qnounwind |
UNWIND NOUNWIND | Specifies default behavior for saving and restoring from non-volatile registers during a procedure call.
| -qunwind Option |
|
-qzerosize -qnozerosize |
ZEROSIZE NOZEROSIZE | Improves performance of FORTRAN 77 and some Fortran 90 and Fortran 95
programs by preventing checking for zero-sized character strings and
arrays.
| -qzerosize Option |
The following options help you avoid, detect, and correct problems in your XL Fortran programs and can save you having to refer as frequently to Problem Determination and Debugging.
In particular, -qlanglvl helps detect portability problems early in the compilation process by warning of potential violations of the Fortran standards. These can be due to extensions in the program or due to compiler options that allow such extensions.
Other options, such as -C and -qflttrap, detect and/or prevent run-time errors in calculations, which could otherwise produce incorrect output.
Because these options require additional checking at compile time and some of them introduce run-time error checking that slows execution, you may need to experiment to find the right balance between extra checking and slower compilation and execution performance.
Using these options can help to minimize the amount of problem determination and debugging you have to do. Other options you may find useful while debugging include:
Table 5. Options for Debugging and Error Checking
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
|
-C -qcheck -qnocheck |
CHECK NOCHECK | Checks each reference to an array element, array section, or character
substring for correctness. Out-of-bounds references are reported as
severe errors if found at compile time and generate SIGTRAP signals
at run time.
| -C Option |
|
-D -qdlines -qnodlines |
DLINES NODLINES | Specifies whether fixed source form lines with a D in column 1 are
compiled or treated as comments.
| -D Option |
|
-g -qdbg -qnodbg |
DBG NODBG | Generates debug information for use by a symbolic debugger.
| -g Option |
|
-qflttrap [=suboptions] -qnoflttrap |
FLTTRAP [(suboptions)] NOFLTTRAP | Determines what types of floating-point exception conditions to detect at
run time. The program receives a SIGFPE signal when the corresponding exception occurs.
| -qflttrap Option |
|
-qfullpath -qnofullpath | Records the full, or absolute, path names of source and include files in
object files compiled with debugging information (-g option).
| -qfullpath Option | |
| -qhalt=sev | HALT(sev) | Stops before producing any object, executable, or assembler source files
if the maximum severity of compile-time messages equals or exceeds the
specified severity. severity is one of i, l, w, e, s, u, or q,
meaning informational, language, warning, error, severe error, unrecoverable
error, or a severity indicating "don't stop".
| -qhalt Option |
|
-qinitauto[=hex_value] -qnoinitauto | Initializes each byte or word (4 bytes) of storage for automatic
variables to a specific value, depending on the length of the
hex_value. This helps you to locate variables that are
referenced before being defined. For example, by using both the
-qinitauto option to initialize REAL variables with a
signaling NAN value and the -qflttrap option, it is possible to
identify references to uninitialized REAL variables at run
time.
| -qinitauto Option | |
|
-qlanglvl={ 77std | 90std | 90pure | 95std | 95pure | extended}
|
LANGLVL({ 77STD | 90STD | 90PURE | 95STD | 95PURE | EXTENDED}) | Determines which language standard (or superset, or subset of a standard)
to consult for nonconformance. It identifies nonconforming source code
and also options that allow such nonconformances.
| -qlanglvl Option |
|
-qsaa -qnosaa |
SAA NOSAA | Checks for conformance to the SAA FORTRAN language definition. It identifies nonconforming source code and also options that allow such nonconformances. | -qsaa Option |
|
-qsigtrap[= trap_handler] | Installs xl__trce or a predefined or user-written trap handler
in a main program.
| -qsigtrap Option | |
|
-qxlines -qnoxlines |
XLINES NOXLINES | Specifies whether fixed source form lines with a X in column 1 are
treated as source code and compiled, or treated instead as comments.
| -qxlines Option |
The following options determine whether the compiler produces a listing (.lst file), what kinds of information go into the listing, and what the compiler does about any error conditions it detects.
Some of the options in Options for Error Checking and Debugging can also produce compiler messages.
Table 6. Options That Control Listings and Messages
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -# | Generates information on the progress of the compilation without actually
running the individual components.
| -# Option | |
|
-qattr[=full] -qnoattr |
ATTR[(FULL)] NOATTR | Specifies whether to produce the attribute component of the attribute and
cross-reference section of the listing.
| -qattr Option |
|
-qflag= listing_severity: terminal_severity -w |
FLAG (listing_severity, terminal_severity) | Limits the diagnostic messages to those of a specified level or
higher. Only messages with severity listing_severity or higher
are written to the listing file. Only messages with severity
terminal_severity or higher are written to the terminal. -w is
a short form for -qflag=e:e.
| -qflag Option |
|
-qlist -qnolist |
LIST NOLIST | Specifies whether to produce the object section of the listing.
| -qlist Option |
|
-qlistopt -qnolistopt |
LISTOPT NOLISTOPT | Determines whether to show the setting of every compiler option in the
listing file or only selected options. These selected options include
those specified on the command line or directives plus some that are always
put in the listing.
| -qlistopt Option |
| -qnoprint | Prevents the listing file from being created, regardless of the settings
of other listing options.
| -qnoprint Option | |
|
-qphsinfo -qnophsinfo |
PHSINFO NOPHSINFO | Determines whether timing information is displayed on the terminal for
each compiler phase.
| -qphsinfo Option |
|
-qreport[={ hotlist}...] -qnoreport |
REPORT [({ HOTLIST}...)] NOREPORT | Determines whether to produce transformation reports showing how loops
are optimized.
| -qreport Option |
|
-qsource -qnosource |
SOURCE NOSOURCE | Determines whether to produce the source section of the listing.
| -qsource Option |
|
-qsuppress [= nnnn-mmm[:nnnn-mmm...] | cmpmsg] | -qnosuppress | Specifies which messages to suppress from the output stream. | -qsuppress Option | |
|
-qxref -qnoxref -qxref=full |
XREF NOXREF XREF(FULL) | Determines whether to produce the cross-reference component of the
attribute and cross-reference section of the listing.
| -qxref Option |
| -v | Traces the progress of the compilation by displaying the name and
parameters of each compiler component that is executed by the invocation
command.
| -v Option | |
| -V | Traces the progress of the compilation by displaying the name and
parameters of each compiler component that is executed by the invocation
command. These are displayed in a shell-executable format.
| -V Option |
The following options help you maintain compatibility between your XL Fortran source code on past, current, and future hardware platforms or help you port programs to XL Fortran with a minimum of changes.
The -qfree=ibm form of the -qfree Option also provides compatibility with VS FORTRAN free source
form.
Table 7. Options for Compatibility
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -qautodbl=setting | AUTODBL(setting) | Provides an automatic means of converting single-precision floating-point
calculations to double-precision and of converting double-precision
calculations to extended-precision. Use one of the following
settings: none, dbl, dbl4, dbl8, dblpad, dblpad4, or dblpad8.
| -qautodbl Option |
|
-qcclines -qnocclines |
CCLINES NOCCLINES | Determines whether the compiler recognizes conditional compilation
lines.
| -qcclines Option |
|
-qctyplss [=([no]arg)] -qnoctyplss |
CTYPLSS [([NO]ARG)] NOCTYPLSS | Specifies whether character constant expressions are allowed wherever
typeless constants may be used. This language extension might be needed
when you are porting programs from other platforms. Suboption
arg specifies that Hollerith constants used as actual arguments will
be treated as integer actual arguments.
| -qctyplss Option |
|
-qddim -qnoddim |
DDIM NODDIM | Specifies that the bounds of pointee arrays are re-evaluated each time
the arrays are referenced and removes some restrictions on the bounds
expressions for pointee arrays.
| -qddim Option |
|
-qdpc -qdpc=e -qnodpc |
DPC DPC(E) NODPC | Increases the precision of real constants, for maximum accuracy when
assigning real constants to DOUBLE PRECISION variables. This
language extension might be needed when you are porting programs from other
platforms.
| -qdpc Option |
|
-qescape -qnoescape |
ESCAPE NOESCAPE | Specifies how the backslash is treated in character strings, Hollerith
constants, H edit descriptors, and character string edit descriptors.
It can be treated as an escape character or as a backslash character.
This language extension might be needed when you are porting programs from
other platforms.
| -qescape Option |
| -qextern=names | Allows user-written procedures to be called instead of XL Fortran
intrinsics. names is a list of procedure names separated by
colons. The procedure names are treated as if they appear in an
EXTERNAL statement in each compilation unit being compiled. If
any of your procedure names conflict with XL Fortran intrinsic procedures, use
this option to call the procedures in the source code instead of the intrinsic
ones.
| -qextern Option | |
|
-qextname[=name:name...] -qnoextname |
EXTNAME[(name:name...)] NOEXTNAME | Adds an underscore to the names of all global entities, which helps in porting programs from systems where
this is a convention for mixed-language programs.
| -qextname Option |
|
-qintlog -qnointlog |
INTLOG NOINTLOG | Specifies that you can mix integer and logical values in expressions and
statements.
| -qintlog Option |
| -qintsize=bytes | INTSIZE(bytes) | Sets the size of default INTEGER and LOGICAL
values.
| -qintsize Option |
|
-qlog4 -qnolog4 |
LOG4 NOLOG4 | Specifies whether the result of a logical operation with logical operands
is a LOGICAL(4) or is a LOGICAL with the maximum length of
the operands.
| -qlog4 Option |
|
-qnullterm -qnonullterm |
NULLTERM NONULLTERM | Appends a null character to each character constant expression that is
passed as a dummy argument, to make it more convenient to pass strings to C
functions.
| -qnullterm Option |
|
-1 -qonetrip -qnoonetrip |
ONETRIP NOONETRIP | Executes each DO loop in the compiled program at least once if
its DO statement is executed, even if the iteration count is
0.
| -1 Option |
|
-qport [=suboptions] -qnoport |
PORT [(suboptions)] NOPORT | Increases flexibility when porting programs to XL Fortran by providing a
number of options to accommodate other Fortran language extensions.
| -qport Option |
|
-qposition= {appendold | appendunknown} |
POSITION( {APPENDOLD | APPENDUNKNOWN}) | Positions the file pointer at the end of the file when data is written
after an OPEN statement with no POSITION= specifier and the
corresponding STATUS= value (OLD or UNKNOWN) is
specified.
| -qposition Option |
|
-qqcount -qnoqcount |
QCOUNT NOQCOUNT | Accepts the Q character-count edit descriptor (Q) as
well as the extended-precision Q edit descriptor
(Qw.d). With -qnoqcount, all
Q edit descriptors are interpreted as the extended-precision
Q edit descriptor.
| -qqcount Option |
| -qrealsize=bytes | REALSIZE(bytes) | Sets the default size of REAL, DOUBLE PRECISION,
COMPLEX, and DOUBLE COMPLEX values.
| -qrealsize Option |
|
-qsave[={all | defaultinit}] -qnosave |
SAVE{(ALL | DEFAULTINIT)} NOSAVE | Specifies the default storage class for local variables. -qsave,
-qsave=all, or -qsave=defaultinit sets the default storage class to
STATIC, while -qnosave sets it to AUTOMATIC.
Specify -qsave for xlf, xlf_r, f77, or fort77 to duplicate the behaviour of FORTRAN77 commands. | -qsave Option |
|
-u -qundef -qnoundef |
UNDEF NOUNDEF | Specifies whether implicit typing of variable names is permitted.
-u and -qundef have the same effect as the IMPLICIT NONE statement
that appears in each scope that allows implicit statements.
| -u Option |
| -qxflag=oldtab | XFLAG(OLDTAB) | Interprets a tab in columns 1 to 5 as a single character (for fixed
source form programs).
| -qxflag=oldtab Option |
| -qxlf77=settings | XLF77(settings) | Provides compatibility with XL Fortran for AIX(R) Versions 1 and 2 aspects of language semantics and I/O data format that have
changed. Most of these changes are required by the Fortran 90
standard.
| -qxlf77 Option |
|
-qxlf90= {[no]signedzero | [no]autodealloc} |
XLF90( {[no]signedzero | [no]autodealloc}) | Determines whether the compiler provides the Fortran 90 or the Fortran 95
level of support for certain aspects of the language.
| -qxlf90 Option |
The following option is intended for writing new programs. It
changes the program in ways that would otherwise require source-code
changes.
Table 8. Option for Fortran 90 Extensions
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -qinit=f90ptr | INIT(f90ptr) | Makes the initial association status of pointers disassociated.
| -qinit Option |
To take maximum advantage of the system floating-point performance and precision, you may need to specify details of how the compiler and XLF-compiled programs perform floating-point calculations.
Table 9. Options for Floating-Point Processing
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -qfloat=options | FLOAT(options) | Determines how the compiler generates or optimizes code to handle
particular types of floating-point calculations.
| -qfloat Option |
|
-qieee={ Near | Minus | Plus | Zero} -y{n|m|p|z} |
IEEE({Near | Minus | Plus | Zero}) | Specifies the rounding mode for the compiler to use when evaluating
constant floating-point expressions at compile time.
| -qieee Option |
The following options control the way the ld command processes object files during compilation. Some of these options are passed on to ld and are not processed by the compiler at all.
You can actually include ld options on the compiler command line, because the compiler passes unrecognized options on to the linker.
In the table, an * indicates that the option is processed
by the ld command, rather than the XL Fortran compiler; you can
find more information about these options in the man pages for the ld command.
Table 10. Options That Control Linking
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -c | Produces an object file instead of an executable file.
| -c Option | |
| -Ldir* | Looks in the specified directory for libraries specified by the
-l option.
| -L Option | |
| -lkey* | Searches the specified library file, where key selects the file
libkey.dylib or libkey.a.
| -l Option | |
|
-qcommon -qnocommon |
COMMON NOCOMMON | Controls whether global variables are allocated in the common or data
section of the object file.
| -qcommon Option |
|
-qpic -qnopic | Generates Position Independent Code (PIC) that can be used in shared
libraries.
| -qpic Option |
These options can help to do the following:
Table 11. Options That Control the Compiler Internal Operation
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
| -Bprefix | Determines a substitute path name for executable files used during
compilation, such as the compiler or linker. It can be used in
combination with the -t option, which determines which of these
components are affected by -B.
| -B Option | |
|
-Fconfig_file -Fconfig_file: stanza -F:stanza | Specifies an alternative configuration file, the stanza to use within the
configuration file, or both.
| -F Option | |
|
-NSbytes -qSPILLsize= bytes |
SPILLsize (bytes) | Specifies the size of internal program storage areas.
| -N Option |
|
-qmaxmem= Kbytes |
MAXMEM (Kbytes) | Limits the amount of memory that the compiler allocates while performing
specific, memory-intensive optimizations to the specified number of
kilobytes. A value of -1 allows optimization to take as much memory as
it needs without checking for limits.
| -qmaxmem Option |
| -tcomponents | Applies the prefix specified by the -B option to the designated
components. components can be one or more of F, c,
I, a, h, b, z, or l, with no separators, corresponding to the C
preprocessor, the compiler, the interprocedural analysis (IPA) tool, the
assembler, the loop optimizer, the code generator, the binder, and the linker, respectively.
| -t Option | |
| -Wcomponent,options | Passes the listed options to a component that is executed during
compilation. component is F, c, I, a, z, or l,
corresponding to the C preprocessor, the compiler, the interprocedural
analysis (IPA) tool, the assembler, the binder, and the linker, respectively.
| -W Option |
The following options are obsolete for either or both of the following reasons:
Notes:
Table 12. Options That Are Obsolete or Not Recommended
| Command-Line Option | @PROCESS Directive | Description | See Topic |
|---|---|---|---|
|
-qcharlen= length |
CHARLEN (length) | Obsolete. It is still accepted, but it has no effect. The maximum length for character constants and subobjects of constants is 32 767 bytes (32 KB). The maximum length for character variables is 268 435 456 bytes (256 MB). | -qcharlen Option |
|
-qrecur -qnorecur |
RECUR NORECUR | Not recommended. Specifies whether external subprograms may be
called recursively.
For new programs, use the RECURSIVE keyword, which provides a standard-conforming way of using recursive procedures. If you specify the -qrecur option, the compiler must assume that any procedure could be recursive. Code generation for recursive procedures may be less efficient. Using the RECURSIVE keyword allows you to specify exactly which procedures are recursive. | -qrecur Option |