Compiling C and C++ Programs

Introduction

The SAS/C C and C++ cross-platform compiler accepts a number of options that allow you to alter the way code is generated, the appearance of listing files, and other aspects of compilation. This chapter explains what options are available and how to specify them.

Since the global optimizer and object module disassembler (OMD) are often executed as part of compilation, the options accepted by the global optimizer and OMD are also discussed in this chapter. The global optimizer and OMD are also discussed in Chapter 5, "Using the Global Optimizer and the Object Module Disassembler" on page 49.

Note: Several compiler options have new names in this release. For backward compatibility with previous releases, you can also use the old names. For details, see Appendix E, "Compatibility Notes" on page 115.

Syntax

As described in Chapter 2, "Using the SAS/C® Cross-Platform Compiler and C++ Development System" on page 9, the basic syntax for invoking the sascc370 compiler driver to compile your C object code is as follows:

 sascc370 [options] [filename1 [filename2...]]
The basic syntax for invoking the sasCC370 compiler driver to compile your C++ object code is as follows:

 sasCC370 [options] [filename1 [filename2...]]
The options argument for sascc370 and sasCC370 can be one or more of the driver options described in the section "Option Descriptions" on page 31. You can also specify cool options when you invoke the compiler driver, which are described in Chapter 6, "Pre-Linking C and C++ Programs" on page 53, and CICS preprocessor options, which are described in Chapter 4, "Using the SAS/C® CICS™ Command Preprocessor" on page 45."

Specifying Phase of Compilation of C and C++ Programs

The compilation of a C or C++ program with the cross-platform compiler occurs in the following phases:

  1. CICS pre-processing
  2. C++ parsing
  3. C parsing
  4. Optimization
  5. Code generation
  6. Pre-Linking
Some of the options passed to the sascc370 or sasCC370 compiler driver apply only to one of these phases. To indicate the particular phase of compilation, you must use the following syntax when specifying these options:

 -Wphase,option
Note: There is no space after the comma between the phase and the option specifications.

The phase can be any one of the following:

Note: This book uses italics to help you distinguish between the letter l and the number 1.

Examples

The following examples illustrate how the compilation phase is specified:

 -Wg,-a
The -Wg specification indicates that the -a option should be passed to the global optimization phase of the compilation. The -a option specifies that the global optimizer should assume worst-case aliasing.

Note: All of the global optimizer options described in this chapter can also be passed to the compiler driver without specifying the compilation phase. For example, to pass the -a option directly, specify -Oa.

 -WP,-d
The -WP specification indicates that the -d option should be passed to the CICS command preprocessor. The -d option is described in Chapter 4, "Using the SAS/C® CICS™ Command Preprocessor" on page 45.

Cross-Platform Compiler Defaults

The SAS/C Cross-Platform Compiler has several options that are specified by default. Most options that begin with -K have both a positive and negative form. Most of these default to their negative form if unspecified, but a few default to their positive form.

For example, if you do not specify the -Kat option, the compiler will not allow the use of the call-by-reference operator @; specifying -Knoat has the same effect. Options such as -Knoextname behave the opposite way. By default, the compiler processes extended names (-Kextname). To disable this feature, you must specify the -Knoextname option. Table 10 on page 26 lists the default for each compiler option with a positive and negative form.

All other compiler options default to their negative form if unspecified. For example, if you do not specify the -g option, the compiler does not generate a .dbg370 debugging information file.

If you do not specify any compiler options, the cross-compiler generates pre-linked, non-reentrant object code, by default. Note that there is no compiler option to specify pre-linking; the -c option is provided to turn pre-linking off. Use the -Krent or -Krentext options to enable reentrant modification of external data.

Option Summary

The cross-platform compiler options are summarized in Table 10 on page 26. A more detailed description of each option is provided in the section "Option Descriptions" on page 31.

The option specifications are listed in the first column of the table. The second column indicates whether the option can be negated. An exclamation point (!) means that the option can be negated. A plus sign (+) means that the option cannot be negated. Only options that begin with -K can be negated. All other options cannot be negated. To negate a -K option, precede the option name with no. For example, to negate the -Kasciiout option, specify -Knoasciiout. The third column lists the default for each option that can be negated.

TABLE 10. Compiler Options

--------------------------------------------------------------------------------------------------------------------------
| Option                     | Negation  | Default        | Description                                                  |
==========================================================================================================================
| -c                         | +         |                | Suppress pre-linking.                                        |
--------------------------------------------------------------------------------------------------------------------------
| -cf                        | +         |                | For C compilations: Require function prototypes in           |
|                            |           |                | scope.                                                       |
--------------------------------------------------------------------------------------------------------------------------
| -cxx                       | +         |                | Specifies to sascc370 that .c files should be                |
|                            |           |                | interpreted as C++ programs. The C++ library will be         |
|                            |           |                | included in all linking.                                     |
--------------------------------------------------------------------------------------------------------------------------
| -Dsym[=val]                | +         |                | Defines the symbol sym as having the value specified         |
|                            |           |                | by value during the preprocessing phase.                     |
--------------------------------------------------------------------------------------------------------------------------
| -g                         | +         |                | Generate debuggable code and produce a .dbg370               |
|                            |           |                | debugging information file. (See -Kdebug.)                   |
--------------------------------------------------------------------------------------------------------------------------
| -Gfn                       | +         |                | Specify the maximum number of floating-point                 |
|                            |           |                | registers (n = 0 through 2). Note: -Gfn and -Kfreg           |
|                            |           |                | are synonyms.                                                |
--------------------------------------------------------------------------------------------------------------------------
| -Gvn                       | +         |                | Specify the maximum number of registers that the             |
|                            |           |                | optimizer can assign to register variables (n = 0 through    |
|                            |           |                | 6). Note: -Gvn and -Kgreg are synonyms.                      |
--------------------------------------------------------------------------------------------------------------------------
| -Ipathname                 | +         |                | Append pathname to the list of directories searched for      |
|                            |           |                | include files.                                               |
--------------------------------------------------------------------------------------------------------------------------
| -Kalias                    | !         | -Knoalias      | Specifies that the global optimizer should assume            |
|                            |           |                | worst-case aliasing. Note: -Oa and -Kalias are               |
|                            |           |                | synonyms.                                                    |
--------------------------------------------------------------------------------------------------------------------------
| -Kasciiout                 | !         | -Knoasciiout   | Character string constants are output as ASCII values.       |
--------------------------------------------------------------------------------------------------------------------------
| -Kat                       | !         | -Knoat         | Allow the use of the call-by-reference operator @.           |
--------------------------------------------------------------------------------------------------------------------------
| -Kbitfield=n               | +         |                | For C compilations: allows for fields that are not int.      |
|                            |           |                | Sets the allocation unit size for int to be n.               |
|                            |           |                |                                                              |
|                            |           |                | For C++ compilations: sets the allocation unit size for      |
|                            |           |                | int to be n. C++ always allows non-int bitfields.            |
--------------------------------------------------------------------------------------------------------------------------
| -Kbytealign                | !         | -Knobytealign  | Align all data on byte boundaries.                           |
--------------------------------------------------------------------------------------------------------------------------
| -Kcomnest                  | !         | -Knocomnest    | For C compilations: Allow nested comments.                   |
--------------------------------------------------------------------------------------------------------------------------
| -Kcomplexity=n             | +         |                | Specify the maximum complexity that a function can           |
|                            |           |                | have and remain eligible for default inlining. Note:         |
|                            |           |                | -Oic and -Kcomplexity are synonyms.                          |
--------------------------------------------------------------------------------------------------------------------------
| -Kdbgmacro                 | !         | -Knodbgmacro   | Specify that macro names should be saved in the              |
|                            |           |                | debugger file.                                               |
--------------------------------------------------------------------------------------------------------------------------
| -Kdbhook                   | !         | -Knodbhook     | Generate debugger hooks.                                     |
--------------------------------------------------------------------------------------------------------------------------
| -Kdebug[=dbg370-filename]  | !         | -Knodebug      | Generate debuggable code and produce a .dbg370               |
|                            |           |                | debugging information file. Optionally, specify the          |
|                            |           |                | name of the debugging information file.                      |
|                            |           |                | Note: -Kdebug and -g are similar. -Kdebug allows             |
|                            |           |                | a filename argument.                                         |
--------------------------------------------------------------------------------------------------------------------------
| -Kdepth=n                  | +         |                | Specify the maximum depth of functions to be inlined.        |
|                            |           |                | Note: -Oid and -Kdepth are synonyms.                         |
--------------------------------------------------------------------------------------------------------------------------
| -Kdollars                  | !         | -Knodollars    | Allow the use of the $ character in identifiers, except as   |
|                            |           |                | the first character.                                         |
--------------------------------------------------------------------------------------------------------------------------
| -Kexclude                  | !         | -Knoexclude    | For C compilations: Omit listing lines that are              |
|                            |           |                | excluded by preprocessor statements from the                 |
|                            |           |                | formatted source listing.                                    |
--------------------------------------------------------------------------------------------------------------------------
| -Kfreg=n                   | +         |                | Specify the maximum number of floating-point                 |
|                            |           |                | registers (n=0 through 2). Note: -Gfn and -Kfreg             |
|                            |           |                | are synonyms.                                                |
--------------------------------------------------------------------------------------------------------------------------
| -Kgreg=n                   | +         |                | Specify the maximum number of registers that the             |
|                            |           |                | optimizer can assign to register variables (n=0 through      |
|                            |           |                | 6). Note: -Gvn and -Kgreg are synonyms.                      |
--------------------------------------------------------------------------------------------------------------------------
| -Khlist                    | !         | -Knohlist      | For C compilations: Print standard header files in the       |
|                            |           |                | formatted source listing.                                    |
--------------------------------------------------------------------------------------------------------------------------
| -Kigline                   | !         | -Knoigline     | Ignore #line statements in the input file.                   |
--------------------------------------------------------------------------------------------------------------------------
| -Kilist                    | !         | -Knoilist      | For C compilations: Print the source referenced by the       |
|                            |           |                | #include statement in the formatted source listing.          |
--------------------------------------------------------------------------------------------------------------------------
| -Kindep                    | !         | -Knoindep      | Generate code that can be called before the run-time         |
|                            |           |                | library framework is initialized or code that can be used    |
|                            |           |                | for interlanguage communication.                             |
--------------------------------------------------------------------------------------------------------------------------
| -Kjapan                    | !         | -Knojapan      | Translates keywords and identifiers that are in              |
|                            |           |                | uppercase to lowercase before they are processed by          |
|                            |           |                | the compiler.                                                |
--------------------------------------------------------------------------------------------------------------------------
| -Klisting[=list-filename]  | !         | -Knolisting    | For C compilations: Generate a listing file and,             |
|                            |           |                | optionally, specify the listing file name.                   |
--------------------------------------------------------------------------------------------------------------------------
| -Kloop                     | !         | -Knoloop       | Specify that the global optimizer should perform loop        |
|                            |           |                | optimizations. (See -Ol.)                                    |
--------------------------------------------------------------------------------------------------------------------------
| -Kmaclist                  | !         | -Knomaclist    | For C compilations: Print macro expansions in the            |
|                            |           |                | formatted source listing.                                    |
--------------------------------------------------------------------------------------------------------------------------
| -Knarrow                   | !         | -Knonarrow     | For C compilations: Make the listing more narrow.            |
--------------------------------------------------------------------------------------------------------------------------
| -Knodbgcmprs               | !         | -Kdbgcmprs     | Do not compress debugging information file.                  |
--------------------------------------------------------------------------------------------------------------------------
| -Knoextname                | !         | -Kextname      | Disable the use of extended names.                           |
--------------------------------------------------------------------------------------------------------------------------
| -Knohmulti                 | !         | -Khmulti       | For C compilations: Specifies that system include files      |
|                            |           |                | will only be included once.                                  |
--------------------------------------------------------------------------------------------------------------------------
| -Knoimulti                 | !         | -Kimulti       | For C compilations: Specifies that local include files       |
|                            |           |                | will only be included once.                                  |
--------------------------------------------------------------------------------------------------------------------------
| -Knoinline                 | !         | -Kinline       | Disable all inlining during the optimization phase. (See     |
|                            |           |                | Oin.)                                                        |
--------------------------------------------------------------------------------------------------------------------------
| -Knoinlocal                | !         | -Kinlocal      | Disable inlining of single-call, static functions during     |
|                            |           |                | the optimization phase. (See -Oil.)                          |
--------------------------------------------------------------------------------------------------------------------------
| -Knolineno                 | !         | -Klineno       | Disable identification of source lines in run-time           |
|                            |           |                | messages emitted by the SAS/C Library.                       |
--------------------------------------------------------------------------------------------------------------------------
| -Knostringdup              | !         | -Kstringdup    | Create a single copy of identical string constants.          |
--------------------------------------------------------------------------------------------------------------------------
| -Knousearch                | !         | -Kusearch      | Specify #include file search rules that are not typical      |
|                            |           |                | of UNIX.                                                     |
--------------------------------------------------------------------------------------------------------------------------
| -Komd[=omd-filename]       | !         | -Knoomd        | Invoke the object module disassembler and, optionally,       |
|                            |           |                | specify the .omd listing file name. Note: -Komd and          |
|                            |           |                | -S are similar. -Komd allows a filename argument.            |
--------------------------------------------------------------------------------------------------------------------------
| -Koptimize                 | !         | -Knooptimize   | Execute the global optimizer phase of the compiler.          |
|                            |           |                | Note: -O and -Koptimize are synonyms.                        |
--------------------------------------------------------------------------------------------------------------------------
| -Koverload                 | !         | -Knooverload   | For C++ compilations: Turn on recognition of the             |
|                            |           |                | overload C++ keyword.                                        |
--------------------------------------------------------------------------------------------------------------------------
| -Kpagesize=nn              | +         |                | For C compilations: Specify the number of lines per          |
|                            |           |                | page for source and cross-reference listings.                |
--------------------------------------------------------------------------------------------------------------------------
| -Kpflocal                  | !         | -Knopflocal    | Assume that all functions are _ _local unless                |
|                            |           |                | _ _remote was explicitly specified in the declaration.       |
--------------------------------------------------------------------------------------------------------------------------
| -Kposix                    | !         | -Knoposix      | Create a POSIX-compliant program.                            |
--------------------------------------------------------------------------------------------------------------------------
| -Kppix                     | !         | -Knoppix       | For C compilations: Allow nonstandard                        |
|                            |           |                | token-pasting.                                               |
--------------------------------------------------------------------------------------------------------------------------
| -Krdepth=n                 | +         |                | Specifies the maximum level of recursion to be inlined.      |
|                            |           |                | Note: -Oir and -Krdepth are synonyms.                        |
--------------------------------------------------------------------------------------------------------------------------
| -Kredef                    | !         | -Knoredef      | Allow redefinition and stacking of #define names.            |
--------------------------------------------------------------------------------------------------------------------------
| -Krefdef                   | !         | -Knorefdef     | Force the use of the strict reference-definition model       |
|                            |           |                | for external linkage of _ _rent identifiers.                 |
--------------------------------------------------------------------------------------------------------------------------
| -Krent                     | !         | -Knorent       | Support reentrant modification of static and external        |
|                            |           |                | data.                                                        |
--------------------------------------------------------------------------------------------------------------------------
| -Krentext                  | !         | -Knorentext    | Support reentrant modification of external data.             |
--------------------------------------------------------------------------------------------------------------------------
| -Ksingleret                | !         | -Knosingleret  | Forces the code generator to generate a single return        |
|                            |           |                | sequence at the end of each function.                        |
--------------------------------------------------------------------------------------------------------------------------
| -Ksmpxivec                 | !         | -Knosmpxivec   | Generate a CSECT with a unique name of the form              |
|                            |           |                | sname@. in place of @EXTVEC# (for SMP support).              |
--------------------------------------------------------------------------------------------------------------------------
| -Ksname=sname              | +         |                | Define sname as the SNAME for a compilation.                 |
--------------------------------------------------------------------------------------------------------------------------
| -Ksource                   | !         | -Knosource     | For C compilations: Output a formatted source listing        |
|                            |           |                | of the program to the listing file.                          |
--------------------------------------------------------------------------------------------------------------------------
| -Ksrcis=source-filename    | +         |                | Override the name of the source file in the debugging        |
|                            |           |                | information (.dbg370) file.                                  |
--------------------------------------------------------------------------------------------------------------------------
| -Kstrict                   | !         | -Knostrict     | For C compilations: Enable an extra set of warning           |
|                            |           |                | messages for questionable or nonportable code.               |
--------------------------------------------------------------------------------------------------------------------------
| -Ktrigraphs                | !         | -Knotrigraphs  | For C compilations: Enable translation of ANSI               |
|                            |           |                | standard trigraphs.                                          |
--------------------------------------------------------------------------------------------------------------------------
| -Kundef                    | !         | -Knoundef      | Undefine predefined macros. Note: -U and -Kundef             |
|                            |           |                | are synonyms.                                                |
--------------------------------------------------------------------------------------------------------------------------
| -Kuse_clink                | !         | -Knouse_clink  | Use the clink program instead of cool to pre-link            |
|                            |           |                | the object file.                                             |
--------------------------------------------------------------------------------------------------------------------------
| -Kvstring                  | !         | -Knovstring    | Generate character string literals with a 2-byte length      |
|                            |           |                | prefix.                                                      |
--------------------------------------------------------------------------------------------------------------------------
| -Kxref                     | !         | -Knoxref       | For C compilations: Produce a cross-reference listing.       |
--------------------------------------------------------------------------------------------------------------------------
| -Kzapmin=n                 | +         |                | Specify the minimum size of the patch area, in bytes.        |
--------------------------------------------------------------------------------------------------------------------------
| -Kzapspace=n               | +         |                | Change the size, n, of the patch area generated by the       |
|                            |           |                | compiler.                                                    |
--------------------------------------------------------------------------------------------------------------------------
| -mrc                       | +         |                | Use mainframe return code values instead of                  |
|                            |           |                | UNIX-style values.                                           |
--------------------------------------------------------------------------------------------------------------------------
| -O                         | +         |                | Execute the global optimizer phase of the compiler.          |
|                            |           |                | Note: -O and -Koptimize are synonyms.                        |
--------------------------------------------------------------------------------------------------------------------------
| -Oa                        | +         |                | Specifies that the global optimizer should assume            |
|                            |           |                | worst-case aliasing. Note: -Oa and -Kalias are               |
|                            |           |                | synonyms.                                                    |
--------------------------------------------------------------------------------------------------------------------------
| -Oic=n                     | +         |                | Specify the maximum complexity that a function can           |
|                            |           |                | have and remain eligible for default inlining. Note:         |
|                            |           |                | -Oic and -Kcomplexity are synonyms.                          |
--------------------------------------------------------------------------------------------------------------------------
| -Oid=n                     | +         |                | Specify the maximum depth of functions to be inlined.        |
|                            |           |                | Note: -Oid and -Kdepth are synonyms.                         |
--------------------------------------------------------------------------------------------------------------------------
| -Oil                       | +         |                | Enables inlining of single-call, static functions during     |
|                            |           |                | the optimization phase. Note: -Oil and -Kinlocal             |
|                            |           |                | are synonyms.                                                |
--------------------------------------------------------------------------------------------------------------------------
| -Oin                       | +         |                | Enables inlining of small static and external functions      |
|                            |           |                | during the optimization phase. (Functions defined with       |
|                            |           |                | the _ _inline keyword are inlined by default.) Note:         |
|                            |           |                | -Oin and -Kinline are synonyms.                              |
--------------------------------------------------------------------------------------------------------------------------
| -Oir=n                     | +         |                | Specifies the maximum level of recursion to be inlined.      |
|                            |           |                | Note: -Oir and -Krdepth are synonyms.                        |
--------------------------------------------------------------------------------------------------------------------------
| -Ol                        | +         |                | Specify that the global optimizer should perform loop        |
|                            |           |                | optimizations. Note: -Ol and -Kloop are synonyms.            |
--------------------------------------------------------------------------------------------------------------------------
| -o filename                | +         |                | Specifies the output filename.                               |
--------------------------------------------------------------------------------------------------------------------------
| -P                         | +         |                | Only run the preprocessor on any .c files, generating        |
|                            |           |                | .i files.                                                    |
--------------------------------------------------------------------------------------------------------------------------
| -Qpathname                 | +         |                | Specify an alternative pathname to be searched for the       |
|                            |           |                | cross-platform compiler executable file                      |
--------------------------------------------------------------------------------------------------------------------------
| -S                         | +         |                | Invoke the object module disassembler after a                |
|                            |           |                | successful compilation. (See -Komd.)                         |
--------------------------------------------------------------------------------------------------------------------------
| -Tallres                   | +         |                | Specify that all-resident library routines should be used    |
|                            |           |                | to build an all-resident program. Note: The -Tspe            |
|                            |           |                | option is not allowed in combination with the                |
|                            |           |                | -Tallres option.                                             |
--------------------------------------------------------------------------------------------------------------------------
| -Tcics370                  | +         |                | Specify that CICS is the target.                             |
--------------------------------------------------------------------------------------------------------------------------
| -Tcicsvse                  | +         |                | Specify that CICS running under the VSE operating            |
|                            |           |                | system is the target. Note: The -Tspe option is not          |
|                            |           |                | allowed in combination with the -Tcicsvse option.            |
--------------------------------------------------------------------------------------------------------------------------
| -Tcms370                   | +         |                | Specify CMS running under VM/ESA or VM/XA as                 |
|                            |           |                | the target host operating system.                            |
--------------------------------------------------------------------------------------------------------------------------
| -Tpcms370                  | +         |                | Specify CMS running in System/370 mode                       |
|                            |           |                | (pre-bimodal) as the target host operating system.           |
--------------------------------------------------------------------------------------------------------------------------
| -Tspe                      | +         |                | Specify that the SAS/C SPE library routines should be        |
|                            |           |                | used to build an SPE program. Note: The -Tallres             |
|                            |           |                | and -Tcicsvse options are not allowed in                     |
|                            |           |                | combination with the -Tspe option.                           |
--------------------------------------------------------------------------------------------------------------------------
| -temp=directory            | +         |                | Specify a different temporary directory for the compiler     |
|                            |           |                | to use.                                                      |
--------------------------------------------------------------------------------------------------------------------------
| -U                         | +         |                | Undefine predefined macros. Note: -U and -Kundef             |
|                            |           |                | are synonyms.                                                |
--------------------------------------------------------------------------------------------------------------------------
| -v                         | +         |                | Specify verbose mode.                                        |
--------------------------------------------------------------------------------------------------------------------------
| -w~n                       | +         |                | Cause warning message n to be treated as an error            |
|                            |           |                | condition.                                                   |
--------------------------------------------------------------------------------------------------------------------------
| -w+n                       | +         |                | Specify that warning number n should not be                  |
|                            |           |                | suppressed.                                                  |
--------------------------------------------------------------------------------------------------------------------------
| -wn                        | +         |                | Suppress warning message number n.                           |
--------------------------------------------------------------------------------------------------------------------------

Option Descriptions

This section provides a more detailed description of each of the options that were summarized in Table 10 on page 26. Unless otherwise specified, the options apply to both C and C++ source files.

 -c 
suppresses pre-linking. By default, sascc370 and sasCC370 will invoke the pre-linker after the compilation is complete. The -c option can be used to suppress this default action.

 -cf 
requires that all functions and function pointers have a prototype in scope. If the -cf option is used and a function or function pointer is declared or defined that does not have a prototype, the compiler issues a warning message.

The -cf option is equivalent to the SAS/C Compiler reqproto option. For C compilations only.

 -cxx
specifies to sascc370 that .c files should be interpreted as C++ source files. Also, the C++ library will be used in all linking. This causes sascc370 to be functionally equivalent to sasCC370.

 -Dsym[val]
defines a symbol, sym, and assigns an optional value, val.

The -D option is equivalent to the SAS/C Compiler define option.

 -g 
allows the use of the debugger to trace the execution of statements at run time. (The compiler produces debugging information that is written to the .dbg370 file.) For programs not compiled with -g, only calls can be traced. Note that if you use -g, the -l option, which enables the identification of source lines in run-time messages, is implied. Also note that the -g option causes the compiler to suppress all optimizations as well as store and fetch variables to or from memory more often.

The -g option is equivalent to the SAS/C Compiler and C++ Development Systems debug option. (See -Kdebug.)

 -Gfn 
specifies the maximum number, n, of floating point registers that the optimizer can assign to register variables in a function. The n argument can have a value of 0 through 2, inclusive (the default is 2). The -Gf option is only used with optimization (specified by the -O option).

The -Gf option is equivalent to the SAS/C Compiler freg option. (See -Kfreg.)

 -Gvn 
specifies the maximum number, n, of registers that the optimizer can assign to register variables in a function. -Gv is used with -O only. The n argument is 0 to 6, inclusive (the default is 6).

The -Gv option is equivalent to the SAS/C Compiler greg option. (See -Kgreg.)

 -Ipathname 
appends the specified pathname to the lists of directories searched for include files. See "Header Files" on page 16 for more information about the search path used by the cross-platform compiler.

 -Kalias 
is a synonym for the -Oa option.

 -Kasciiout
causes character string constants to be output as ASCII values. By default, character string constants are output as EBCDIC values.

The -Kasciiout option is equivalent to the SAS/C Compiler asciiout option.

 -Kat 
allows the use of the call-by-reference operator @.

The -Kat option is equivalent to the SAS/C Compiler and C++ Development Systems at option.

 -Kbitfield=n 
specifies the size of the allocation unit for int bitfields. This option requires that you specify a value, n. The values can be either 1, 2, or 4, which specifies that the allocation unit be a char, short, or long, respectively. Note that for C source files, this option allows non-int bitfields. For C++ source files, non-int bitfields are always allowed. Refer to SAS/C Compiler and Library User's Guide, Fourth Edition for more details.

The -Kbitfield option is equivalent to the SAS/C Compiler and C++ Development Systems bitfield option.

 -Kbytealign 
aligns all data on byte boundaries. Most data items, including all those in structures, are generated with only character alignment.

Because formal parameters are aligned according to normal IBM System/370 conventions, even with the -Kbytealign option, you can call functions compiled with byte alignment from functions that are not compiled with byte alignment, and vice versa.

If functions compiled with and without byte alignment are to share the same structures, you must ensure that such structures have exactly the same layout. The layout is not exactly the same if any structure element does not fall on its usual boundary, for example, an int member's offset from the start of the structure is not divisible by 4. You can force such alignment by adding unreferenced elements of appropriate length between elements as necessary. If a shared structure does contain elements with unusual alignment, you must compile all functions that reference the structure using byte alignment.

The -Kbytealign option is equivalent to the SAS/C Compiler and C++ Development Systems bytealign option.

 -Kcomnest
allows nested comments.

The -Kcomnest option is equivalent to the SAS/C Compiler comnest option. For C compilations only.

 -Kcomplexity=n
is a synonym for the -Oic option.

 -Kdbgmacro 
specifies that definitions of macro names should be saved in the .dbg370 debugger file. Note that this substantially increases the size of the file.

The -Kdbgmacro option is equivalent to the SAS/C Compiler dbgmacro option.

 -Kdbhook 
generates hooks in the object code. When you compile a module with the -g option, the -Kdbhook option is implied. -Kdbhook can be used with the -O option to enable debugging of optimized object code.

The -Kdbhook option is equivalent to the SAS/C Compiler dbhook option.

 -Kdebug[=dbg370-filename]
generates debuggable code and produces a .dbg370 debugging information file. Optionally, you can specify the name of the debugging information file with the -Kdebug=dbg370-filename option.

The -Kdebug option is similar to the -g option. When you specify -Kdebug=dbg370-filename, -g is assumed.

 -Kdepth=n
is a synonym for the -Oid option.

 -Kdollars
allows the use of the $ character in identifiers, except as the first character.

The -Kdollars option is equivalent to the SAS/C Compiler dollars option.

 -Kexclude
omits listing lines from the formatted source that are excluded by #if, #ifdef, and so on. For example, in the following sequence


      #ifdef MAX_LINE
           printf("Line overflow\ n");
      #endif
the -Kexclude option omits the printf statement from the formatted source listing if MAX_LINE is not currently defined with the #define command.

The -Kexclude option is equivalent to the SAS/C Compiler exclude option.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Kfreg=n
is a synonym for the -Gf option.

 -Kgreg=n
is a synonym for the -Gv option.

 -Khlist 
prints system header files in the formatted source listing. These are files that are included using the following syntax:


      #include <filename.h>
The -Khlist option is equivalent to the SAS/C Compiler hlist option. See also -Kilist.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Kigline
causes the compiler to ignore any #line statements in the input file.

The -Kigline option is equivalent to the SAS/C Compiler igline option.

 -Kilist 
prints user header files in the formatted source listing. These are files that are included using the following syntax:

           
       #include "filename.h"

The -Kilist option is equivalent to the SAS/C Compiler ilist option. See also -Khlist.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Kindep 
generates code that can be called before the framework is initialized or code that can be used for interlanguage communication.

The -Kindep option is equivalent to the SAS/C Compiler indep option. The SAS/C Compiler and Library User's Guide, Fourth Edition covers the indep option in detail.

 -Kjapan
translates keywords and identifiers that are in uppercase to lowercase before they are processed by the compiler. Print messages in uppercase. This option is intended to be used with terminals or printers that support only uppercase (Roman) characters.

 -Klisting[=list-filename]
produces a listing file for all phases of the compilation and, optionally, directs the listing to the specified file. If you do not specify a file name, the base file name of the source file will be used to construct the listing file name. See the cool pre-linker option -h on page 60 for information about how messages are handled when a listing is produced.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Kloop 
specifies that the global optimizer should perform loop optimizations. This option can only be used with the -O option.

The -Kloop option is equivalent to the SAS/C Compiler loop option. The -Kloop option and the -Ol option are synonyms. Refer to the SAS/C Compiler and Library User's Guide, Fourth Edition for more information about loop optimization.

Note: The behavior of the mainframe SAS/C Compiler is different from the SAS/C Cross-Platform Compiler. Loop optimization is the default on the mainframe.

 -Kmaclist 
prints macro expansions. Source code lines containing macros are printed before macro expansion.

The -Kmaclist option is equivalent to the SAS/C Compiler maclist or mlist option.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Knarrow
compresses the width of the listing to make it fit better on small screens.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Knodbgcmprs 
disables compression of the .dbg370 debugging information file. By default, this information is compressed to save disk space and reduce network traffic while debugging.

The -Knodbgcmprs option is only meaningful when used with the -g option.

 -Knoextname 
disables the use of extended names. By default, external names that are longer than 8 characters will be accepted by the compiler, unless you specify the -Knoextname option. -Knoextname applies only to C compilations; extended names processing cannot be
disabled for C++.

Note: When pre-linking object modules produced by the compiler using -Kextname, cool checks for and prohibits the linking of two object modules with the same section name, by default. (See -Ksname option.) If cool detects an object module that has the same section name as a previously processed object module, it will issue an error message and exit.

Also note that you cannot use cool more than once on any object file that was previously compiled with the -Kextname option. Because cool resolves external references with extended names into their final form, it will not accept references that have been previously resolved.

The -Knoextname option is equivalent to the SAS/C Compiler noextname option. For more information on extended names, refer to the SAS/C Compiler and Library User's Guide, Fourth Edition.

Note: In this release, -Kextname is the default. This differs from previous releases where you had to specify -Kextname explicitly to enable the use of extended function and identifier names.

 -Knohmulti
disables the reinclusion of system header files; these files will only be included once. (System header files are specified within angle brackets.) If -Knohmulti is specified, the cross-platform compiler will only include code from a header file once in a compilation. By default, the cross-platform compiler includes a copy of the header file code every time a #include <filename> statement is encountered, even if the file has already been included.

The -Knohmulti option is equivalent to the SAS/C Compiler nohmulti option. For C compilations only.

 -Knoimulti 
disables the reinclusion of local header files; these files will only be included once. (Local header files are specified within double quotes.) If -Knoimulti is specified, the cross-platform compiler will only include code from a header file once in a compilation. By default, the cross-platform compiler includes a copy of the header file code every time a #include "filename" statement is encountered, even if the file has already been included.

The -Knoimulti option is equivalent to the SAS/C Compiler noimulti option. (Notice that the behavior of the mainframe SAS/C Compiler is different than that of the SAS/C Cross-Platform Compiler. Reinclusion of header files is disabled by default on the mainframe.) For C compilations only.

 -Knoinline 
disables all inlining of functions during the optimization phase. If this option is not specified, functions specified as inline will be inlined by default. (Also see the -Oin option.)

The -Knoinline option is equivalent to the SAS/C Compiler noinline option.

 Knoinlocal 
disables inlining of single-call, static (local) functions. These functions are not inlined by default during the optimization phase. (Also see the -Oil option.)

The -Knoinlocal option is equivalent to the SAS/C Compiler noinlocal option.

 -Knolineno 
disables identification of source lines in run-time messages. When -Knolineno is specified, module size is decreased because the generation of line number and offset tables is not required.

The -Knolineno option is equivalent to the SAS/C Compiler nolineno option.

 -Knostringdup
creates a single copy of identical string constants.

The -Knostringdup option is equivalent to the SAS/C Compiler nostringdup option.

 -Knousearch
specifies include-file search rules that are not typical of UNIX compilers.-Kusearch is the default. See "Header Files" on page 16 for additional information.

 -Komd[=omd-filename]
invokes the object module disassembler (OMD) after successful compilation and, optionally, directs the .omd listing to the specified file. If you do not specify a file name, the compiler derives the listing file name from the basename of the input file with a .omd suffix. Also see the -S option.

 -Koptimize
is a synonym for the -O option.

 -Koverload
turns on recognition of the overload C++ keyword. If you specify this option, the translator recognizes overload as a reserved word; otherwise, it is treated as an identifier. For additional information, see SAS/C C++ Development System User's Guide, First Edition. For C++ compilations only.

 -Kpagesizenn
defines the number of lines per page for source and cross-reference listings. The default is 60 lines per page.

The -Kpagesize=nn option is similar to the SAS/C Compiler pagesize option. For C compilations only.

 -Kpflocal 
assumes that all functions are _ _local unless _ _remote was explicitly specified in the declaration. By default, the compiler treats all function pointers as _ _remote unless they are explicitly declared with the _ _local keyword.

The -Kpflocal option is equivalent to the SAS/C Compiler pflocal option.

 -Kposix
instructs the compiler to create a POSIX-compliant program by setting compile-time and run-time defaults for maximum POSIX compatibility. The -Kposix option has the following effects on compilation:

Additionally, if any compilation in a program's main load module is compiled with the -Kposix option, it has the following effects on the execution of the program:

Note: You should not use the -Kposix option when compiling functions that can be used by both POSIX and non-POSIX applications.

The -Kposix option is equivalent to the SAS/C Compiler posix option. See the SAS/C Compiler and Library User's Guide, Fourth Edition for more information.

 -Kppix
allows nonstandard use of the preprocessor.

If the -Kppix option is in effect, the preprocessor allows token-pasting by treating a comment in macro replacement text as having zero characters. The ANSI Standard defines the ## operator to perform token-pasting.

This option also specifies that the preprocessor should replace macro arguments in string literals. Equivalent functionality can be gained for portability by using the ANSI Standard # operator.

The -Kppix option is equivalent to the SAS/C Compiler ppix option. For C compilations only.

 -Krdepth=n
is a synonym for the -Oir option.

 -Kredef 
allows redefinition and stacking of #define names.

The -Kredef option is equivalent to the SAS/C Compiler redef option.

 -Krefdef 
forces the use of the strict reference-definition model for external linkage of _ _rent identifiers. The -Krefdef option causes the compiler to generate code that forces the use of the strict reference-definition model for reentrant external variables. If the strict reference-definition model is not used, the compiler uses the common model. This option is meaningful primarily when used with the -Krent or -Krentext options. (Strict reference-definition is always used for _ _norent identifiers.)

Because of the fact that a reference is also a definition in the common model, it is also recommended that you use the -Krefdef option when linking with ar370 archives, to cause proper resolution of variable definitions.

The -Krefdef option is equivalent to the SAS/C Compiler and C++ Development Systems refdef option.

 -Krent 
allows reentrant modification of static and external data.

The -Krent option is equivalent to the SAS/C Compiler and C++ Development Systems rent option.

 -Krentext 
allows reentrant modification of external data.

The -Krentext option is equivalent to the SAS/C Compiler and C++ Development Systems rentext option.

 -Ksingleret
forces the cross-platform compiler to generate a single return sequence at the end of each function. By default, the cross-platform compiler generates a return sequence at the location of each return statement within a function. The main advantage of the -Ksingleret option is that it causes a single return from functions that have multiple return statements. The code to execute the single return from the function is emitted at the end of the function, with return statements within the function causing a branch to that single return location.

 -Ksmpxivec 
generates a CSECT that is used in place of @EXTERN#. The CSECT generated by the -Ksmpxivec option has a unique name of the following form:


       sname@.
The sname@. vector provides an alternate mechanism for reentrant initialization of static and extern data that is used with System Modification Program (SMP) update methods, which are described in Programmer's Report: SMP Packaging for SAS/C Based Products.

The -Ksmpxivec option is equivalent to the SAS/C Compiler smpxivec option. For this option to be effective, you must have the SMP libraries.

Note: The -Asmpxivec cool option must be used in conjunction with the -Ksmpxivec compiler option. The -Asmpxivec cool option builds a vector named @EXTVEC# that references the sname@. CSECT generated by the -Ksmpxivec compiler option. For example, the following command could be used to invoke the sascc370 compiler driver:

       sascc370 -Ksmpxivec -Asmpxivec filename.c
In this case, the -Asmpxivec option is passed to the pre-linker. See Chapter 6 on page 53 for information about the -Asmpxivec cool option.

 -Ksname=sname 
defines the section name. The sname argument can be up to seven characters in length.

The section name is assigned by the compiler using the first applicable rule in the following list:

The -Ksname option is equivalent to the SAS/C Compiler and C++ Development Systems sname option.

 -Ksource 
outputs a formatted source listing of the program to the listing file.

The -Ksource option only controls the source listing; the cross-reference listing is requested with the -Kxref option.

The -Ksource option is similar to the SAS/C Compiler source option.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Ksrcis=source-filename
specifies the name of the source file in the debugging file. This option is meaningful only when used with the -g option or -Kdebug option.

 -Kstrict 
enables an extra set of warning messages for questionable or nonportable code. See SAS/C Software Diagnostic Messages, First Edition, for more information.

The -Kstrict option is equivalent to the SAS/C Compiler strict option. For C compilations only.

 -Ktrigraphs 
enables translation of ANSI standard trigraphs.

The -Ktrigraphs option is equivalent to the SAS/C Compiler trigraphs option. For C compilations only.

 -Kundef
is a synonym for the -U option.

 -Kuse_clink 
uses the program clink as the object code preprocessor. By default, the SAS/C C and C++ cross-compiler uses the cool program to prelink the object file. For more information about clink, see Appendix E, "Compatibility Notes" on page 115.

 -Kvstring
generates character string literals with a 2-byte length prefix. This option is used primarily in conjunction with the interlanguage communication feature.

The -Kvstring option is equivalent to the SAS/C Compiler vstring option. For more information on the vstring option, refer to Chapter 3, "Communication with Other Languages," in the SAS/C Compiler Interlanguage Communication Feature User's Guide.

 -Kxref 
produces a cross-reference listing.

The -Kxref option is equivalent to the SAS/C Compiler xref option.

For C compilations only. The SAS/C Cross-Platform C++ Development System does not support listings.

 -Kzapmin=n 
specifies the minimum size of the patch area, in bytes. n refers to the number of bytes in the patch area. The default is 24 bytes.

The -Kzapmin option is equivalent to the SAS/C Compiler and C++ Development Systems zapmin option. For more information about the patch area, refer to the SAS/C Compiler and Library User's Guide, Fourth Edition.

 -Kzapspace=n 
alters the size of the compiler-generated patch area. The size of the patch area can be increased or its generation suppressed. The default is 1.

The -Kzapspace option accepts an integer value between 0 and 22, inclusive, that specifies the factor by which the default patch area size is to be multiplied. If the factor is 0, then no patch area is generated. For example, if the default patch area is 48 bytes and the -Kzapspace option specifies a factor of 3, then the patch area actually generated is 144 bytes long. In no case does the compiler generate more than 512 bytes of patch area.

The -Kzapspace option is equivalent to the SAS/C Compiler zapspace option. For more information about the patch area, refer to the SAS/C Compiler and Library User's Guide, Fourth Edition.

 -mrc 
causes the cross-platform compiler to generate mainframe return codes when syntax and semantic errors are detected during compilation. The mainframe return codes generated when the -mrc option is in effect are summarized in the following table.

TABLE 11. Compiler Return Codes

-------------------------------------------------------------------------------------
| Code  | Definition                                                                |
=====================================================================================
| 0     | No errors or warnings found: object code is generated.                    |
-------------------------------------------------------------------------------------
| 4     | Warning: object code is generated and will probably execute correctly.    |
-------------------------------------------------------------------------------------
| 8     | Serious error: object code is generated but may not execute correctly.    |
-------------------------------------------------------------------------------------
| 12    | Serious error: no object code is generated and pass two of the compiler   |
|       | is not executed.                                                          |
-------------------------------------------------------------------------------------
| 16    | Fatal error. Compilation stops.                                           |
-------------------------------------------------------------------------------------

By default, the cross-platform compiler's return codes are similar to the return codes of a native UNIX compiler. In this case, a return code greater than 0 is an error. This behavior is consistent with what is expected by UNIX tools, such as make.

 -O 
executes the global optimizer phase of the compiler, which optimizes the flow of control and data through an entire function.

Global optimization includes a wide variety of optimizations, such as:

The cross-platform compiler accepts the following options to modify the operation of the global optimizer: -Gfn, -Gvn, -Oa, -Oic=n, -Oid=n, -Oil, Oin, -Oir=n, and -Ol.

The -O option is equivalent to the SAS/C Compiler optimize option. See Chapter 5, "Using the Global Optimizer and the Object Module Disassembler" on page 49 for more information about the optimize option and the global optimizer. (See -Koptimize.)

 -Oa 
disables type-based aliasing assumptions. If -Oa is used, the global optimizer uses worst-case aliasing. Use of this option can significantly reduce the amount of optimization that can be performed. This option can only be used with the -O option.

The -Oa option is equivalent to the SAS/C Compiler alias option. (See -Kalias.)

 -Oic=n 
specifies the maximum complexity that a function can have and remain eligible for default inlining. The range of n is 0 to 20; with 0 specifying that only very small functions should be inlined, and 20 specifying that relatively large functions should be inlined. The -Oic option is set to 0 by default. This option is used with the -Oin option, which enables the default inlining of small static and extern functions.

The -Oic option is equivalent to the SAS/C Compiler complexity option. (See -Kcomplexity.)

 -Oid=n 
defines the maximum depth of function calls to be inlined. The range of n is 0 to 6, and the default value is 3. This option can only be used with the -O option.

The -Oid option is equivalent to the SAS/C Compiler depth option. (See -Kdepth.)

 -Oil 
inlines single-call, static functions. This option can only be used with the -O option.

The -Oil option is equivalent to the SAS/C Compiler inlocal option. (See -Kinlocal.)

 -Oin 
enables inlining of small static and extern functions, in addition to the inlining of functions defined with _ _inline keyword. The complexity of the functions that are inlined, other than those that are defined with the _ _inline keyword, is controlled by the -Oic option. The -Oic option must be specified for some non-zero n to enable the inlining of small functions. The -Oin and -Oic options can only be used with the -O option.

The -Oin option is similar to the SAS/C Compiler inline option. (Even if -Oin is not specified, functions defined with the _ _inline keyword will be inlined.) (See -Kinline.)

 -Oir=n 
defines the maximum level of recursive function calls to be inlined. The range of n is 0 to 6, and the default is 0. This option can only be used with the -O option.

The -Oir option is equivalent to the SAS/C Compiler rdepth option. (See -Krdepth.)

 -Ol 
specifies that the global optimizer should perform loop optimizations. This option can only be used with the -O option.

The -Ol option is equivalent to the SAS/C Compiler loop option. (Notice that the behavior of the mainframe SAS/C Compiler is different than that of the SAS/C Cross-Platform Compiler. Loop optimization is the default on the mainframe.) Refer to the SAS/C Compiler and Library User's Guide, Fourth Edition for more information about loop optimization. (See -Kloop.)

 -o filename 
specifies the name of the output file. If the -c option is used, filename specifies the name of the output object file. Otherwise, filename specifies the name of the executable file. If the -o option is not specified, output is written to the a.out file by default.

The -o option is similar to the SAS/C compiler object option. See SAS/C Compiler and Library User's Guide, Fourth Edition for more information.

 -P 
creates a file containing preprocessed source code for this compilation. Preprocessed source code has all macros and #include files expanded. If the -P option is used, all syntax checking (except in preprocessor directives) is suppressed, no listing file is produced, and no object code is generated.

If -o is specified together with -P, the preprocessed source code is written to the file specified by -o. If -o is not specified, the preprocessed source code is written to a file with a .i extension. The name of the default output file is derived from the basename of the source file.

The -P option is equivalent to the SAS/C Compiler pponly option.

 -Qpathname 
specifies an alternative pathname to be searched for the cross-platform compiler executable files. The location of the executable files that compose the SAS/C Cross-Platform Compiler (sascc370, lc1, lc2, cool, go, and omd) is defined when the SAS/C Cross-Platform Compiler is installed. This location is host specific, and is usually in the host/host-type/bin subdirectory.

 -S
invokes the object module disassembler (OMD) after successful compilation. OMD-only options and selected compilation options are passed to the OMD, as explained in the SAS/C Compiler and Library User's Guide, Fourth Edition.

The -S option is equivalent to the SAS/C Compiler omd option. (See -Komd.)

 -Tallres 
specifies use of the all-resident library, libares.a, which is prepended in front of the resident library, libc.a. The -Tallres option should be specified when developing an all-resident application. Refer to the SAS/C Compiler and Library User's Guide, Fourth Edition for more information about all-resident programs.

Note: The -Tallres option must be combined with either the -Tcms370 or the -Tpcms370 option to generate an all-resident application targeted for CMS.

Note: The -Tspe option is not allowed in combination with the -Tallres option.

 -Tcics370
specifies that CICS is the target. The -Tcics370 option causes the driver to specify the CICS libraries during linking and add the -m option to the cool command.

Note: When you use cool to link a CICS application, you will receive warnings about unresolved references to the following: DFHEI1, DFHEAI, and DFHAI0. These warning messages are expected. You should use the cool option -Aclet to allow the object file to be generated regardless of the warnings. The output object file from cool must subsequently be moved to the target mainframe and linked with the CICS Execution Interface stubs.

 -Tcicsvse
specifies that CICS running under the VSE operating system is the target. The -Tcicsvse option causes the driver to specify the CICS VSE libraries during linking and add the -p option (remove pseudoregisters) and the -m option to the cool command.

Note: The -Tspe option is not allowed in combination with the -Tcicsvse option.

Note: When you use cool to link a CICS application, you will receive warnings about unresolved references to the following: DFHEI1, DFHEAI, and DFHAI0. These warning messages are expected. You should use the cool option -Aclet to allow the object file to be generated regardless of the warnings. The output object file from cool must subsequently be moved to the target mainframe and linked with the CICS Execution Interface stubs.

 -Tcms370 
specifies CMS running under VM/ESA or VM/XA as the target host operating system. The -Tcms370 option should be specified when your application is targeted for CMS under VM/XA, VM/ESA, or VM/SP release 6.

Under VM/XA or VM/ESA, programs can run either in 24-bit addressing mode, or in 31-bit addressing mode.

Note: The cross-platform compiler generates code that is targeted for MVS by default.

 -Tpcms370 
specifies CMS supporting System/370 mode (pre-bimodal) as the target host operating system. The -Tpcms370 option should be specified when your CMS application will run under VM/SP release 5 or earlier. 370 mode does not support 31-bit addressing.

 -Tspe 
specifies use of the SAS/C SPE library, libspe.a, which replaces the resident library, libc.a. The -Tspe option should be specified when developing an SPE application. Refer to the SAS/C Compiler and Library User's Guide, Fourth Edition for more information about systems programming with the SAS/C Compiler.

Note: The -Tspe option must be combined with either the -Tcms370 or the -Tpcms370 option to generate an SPE application targeted for CMS.

Note: The -Tallres and -Tcicsvse options are not allowed in combination with the -Tspe option.

 -temp=directory 
specifies the directory used to store temporary files.

 -U 
undefines predefined macros.

Predefined macros are defined as follows:

           #define DEBUG 1
#define NDEBUG 1
#define I370 1
#define OSVS 1
#define CMS 1
The definition of the DEBUG or the NDEBUG macro depends on whether you have specified the -g option. The OSVS and CMS macro definitions depend on the -Tcms370 and -Tpcms370 options. The OSVS macro is defined if neither the -Tcms370 nor the -Tpcms370 option is specified. If either of these options is specified, the CMS macro is defined.

The -U option is equivalent to the SAS/C Compiler undef option. (See -Kundef.)

 -v 
specifies verbose mode. In verbose mode, the command line that executes each phase of the cross-platform compiler is displayed.

 -w~n 
treats a warning condition as an error condition. The warning condition is identified by its associated message number n. Conditions whose numbers have been specified are treated as errors, and cause an error return code from the compiler. By default, a non-zero value greater than 1 is returned. If the -mrc option is also specified, a return code of 12 will be generated for a warning condition instead of a return code of 4.

Any number of warning conditions can be specified by entering additional -w~ options. See also the -w option.

The -w~ option is similar to the SAS/C Compiler enforce option.

 -w+n 
specifies that a warning, whose number is specified as n, is not to be suppressed.

Any number of warning conditions can be specified by entering additional -w+ options. See also the -wn option.

The -w+ option is similar to the SAS/C Compiler mention option.

 -wn 
ignores a warning condition. Each warning condition is identified by its associated message number n. Conditions whose numbers have been specified are suppressed. No message is generated, and the compiler return code is unchanged. For more information about related messages, see SAS/C Software Diagnostic Messages, First Edition.

Any number of warning conditions can be specified by entering additional -w options. If both -w and -w~ specify the same message number, the warning is enforced.

The -w option is similar to the SAS/C Compiler suppress option.