optsumry.gml

开放源码的编译器open watcom 1.6.0版的源代码

Compiler options may be entered in one of two places.
They may be included in the options list of the command line or they
may be included as comments of the form "C$option", "c$option", or
"*$option" in the source input stream.
The compiler recognizes these special comments as compiler directives.
.np
Some options may only be specified in the options list of the command
line.
Unless otherwise stated, an option can appear on the command line
only.
We also indicate what the default is for an option or group of
options.
.np
When specifying options in the source file, it is possible to
specify more than one option on a line.
For example, the following source line tells &cmpname to not issue any
warning or extension messages.
.exam begin
*$nowarn noext
.exam end
.pc
Note that only the first option must contain the "*$", "C$", or "c$"
prefix.
.np
Short forms are indicated by upper case letters.
.begnote $break
:DTHD.Option:
:DDHD.Description:
.*
.if '&cmpclass' ne 'load-n-go' .do begin
.*
.note 0
.ixm 'options' '0'
(16-bit only)
&cmpname will make use of only 8088/8086 instructions in the generated
object code.
The resulting code will run on 8086 and all upward compatible
processors.
This is the default option for the 16-bit compiler.
.*
.note 1
.ixm 'options' '1'
(16-bit only)
&cmpname will make use of 188/186 instructions in the generated
object code whenever possible.
The resulting code probably will not run on 8086 compatible processors
but it will run on 186 and all upward compatible processors.
.*
.note 2
.ixm 'options' '2'
(16-bit only)
&cmpname will make use of 286 instructions in the generated object
code whenever possible.
The resulting code probably will not run on 8086 or 186 compatible
processors but it will run on 286 and all upward compatible
processors.
.*
.note 3
.ixm 'options' '3'
&cmpname will assume a 386 processor and will generate instructions
based on 386 instruction timings.
.*
.note 4
.ixm 'options' '4'
&cmpname will assume a 486 processor and will generate
386 instructions based on 486 instruction timings.
The code is optimized for 486 processors rather than 386
processors.
.*
.note 5
.ixm 'options' '5'
&cmpname will assume a Pentium processor and will generate
386 instructions based on Pentium instruction timings.
The code is optimized for Pentium processors rather than 386
processors.
This is the default option for the 32-bit compiler.
.*
.note 6
.ixm 'options' '6'
&cmpname will assume a Pentium Pro processor and will generate
386 instructions based on Pentium Pro instruction timings.
The code is optimized for Pentium Pro processors rather than 386
processors.
.*
.note [NO]ALign
.ixm 'ALIGN option'
.ixm 'options' 'ALIGN'
:cmt. .ixm 'NOALIGN option'
:cmt. .ixm 'options' 'NOALIGN'
The "align" option tells the compiler to allocate all COMMON blocks on
paragraph boundaries (multiples of 16).
If you do not want COMMON blocks to be aligned, specify "noalign".
The default is "align".
.*
.note [NO]AUtomatic
.ixm 'AUTOMATIC option'
.ixm 'options' 'AUTOMATIC'
:cmt. .ixm 'NOAUTOMATIC option'
:cmt. .ixm 'options' 'NOAUTOMATIC'
The "automatic" option tells the compiler to allocate all local
variables, including arrays, on the stack.
This is particularly useful for recursive functions or subroutines that
require a new set of local variables to be allocated for each recursive
invocation.
.ix 'stack size'
Note that the "automatic" option may significantly increase the stack
requirements of your application.
You can increase your stack size by using the "STACK" option when you
link your application.
.*
.do end
.*
.if '&cmpclass' eq 'load-n-go' .do begin
.*
.note [NO]ARraycheck
.ixm 'ARRAYCHECK option'
.ixm 'options' 'ARRAYCHECK'
:cmt. .ixm 'NOARRAYCHECK option'
:cmt. .ixm 'options' 'NOARRAYCHECK'
This option is used to control type checking on array arguments.
It may be placed anywhere in the source input stream or it may be
specified in the options list of the command line.
Specifying the "arraycheck" option turns on the generation of type
checking on array arguments while "noarraycheck" turns it off.
The default is "arraycheck".
.np
Using "noarraycheck" allows the programmer, for example, to pass an array
of type INTEGER to an array of type REAL.
Although this is not FORTRAN 77 standard, it allows the sharing of
array storage for data of different types.
You can selectively choose which argument lists are
.us not
to be checked by enclosing the calling statement with *$NOARRAYCHECK
and *$ARRAYCHECK.
.*
.do end
.*
.note BD
.ixm 'BD option'
.ixm 'options' 'BD'
(32-bit only, OS/2 and Windows NT only)
.ix 'dynamic link library applications'
.ix 'DLL applications'
This option causes the compiler to imbed the appropriate DLL library
name in the object file and to include the appropriate DLL
initialization code sequence when the application is linked.
.*
.note BM
.ixm 'BM option'
.ixm 'options' 'BM'
(32-bit only, OS/2 and Windows NT only)
.ix 'multi-threaded applications'
This option causes the compiler to imbed the appropriate multi-thread
library name in the object file.
.*
.note [NO]BOunds
.ixm 'BOUNDS option'
.ixm 'options' 'BOUNDS'
:cmt. .ixm 'NOBOUNDS option'
:cmt. .ixm 'options' 'NOBOUNDS'
The "bounds" option causes the generation of code that performs array
subscript and character substring bounds checking.
.ix 'debugging' 'bounds check'
Note that this option may significantly reduce the performance of your
application but is an excellent way to eliminate many programming
errors.
The default option is "nobounds".
.*
.note BW
.ixm 'BW option'
.ixm 'options' 'BW'
(OS/2, Windows 3.x, and Windows NT only)
This option causes the compiler to import a special symbol so that the
default windowing library code is linked into your application.
.*
.note [NO]CC
.ixm 'CC option'
.ixm 'options' 'CC'
:cmt. .ixm 'NOCC option'
:cmt. .ixm 'options' 'NOCC'
The "cc" option specifies that the output to devices contains carriage
control information that is to be interpreted appropriately for the
output device (e.g., console device).
ASA carriage control characters are converted to ASCII vertical
spacing control characters.
Note that a blank carriage control character will automatically be
generated for list-directed output and will be interpreted as a
single-line spacing command.
.*
.if '&cmpclass' eq 'load-n-go' .do begin
.*
.note [NO]CHeck
.ixm 'CHECK option'
.ixm 'options' 'CHECK'
:cmt. .ixm 'NOCHECK option'
:cmt. .ixm 'options' 'NOCHECK'
.ix 'undefined variable'
.ix 'variable' 'undefined'
This option is used to control undefined variable checking by the
compiler.
It may be placed anywhere in the source input stream or it may be
specified in the options list of the command line.
Specifying the "check" option turns on the generation of undefined
variable checking code, while "nocheck" turns it off.
The default is "check".
.np
.ix 'hexadecimal 80'
The hexadecimal (base 16) value used for undefined variable checking
is 80.
This pattern is stored in each byte that represents the variable's
value before the start of program execution.
If a case arises where the legitimate value of a variable happens
to coincide with the undefined pattern, you may wish to place
*$NOCHECK and *$CHECK option lines around the FORTRAN statement
in question.
.np
At execution-time, formatted output of undefined variables
results in "?" characters being written to the output file.
To disable this feature, place *$NOCHECK and *$CHECK option lines
around the FORTRAN
.kw PRINT
or
.kw WRITE
statement in question.
.*
.do end
.*
.note CHInese
.ixm 'CHINESE option'
.ixm 'options' 'CHINESE'
This option is part of the national language support provided by
&cmpname..
It instructs the compiler that the source code contains characters
from the Traditional Chinese character set.
This includes double-byte characters.
This option enables the use of Chinese variable names.
The compiler's run-time system will ensure that character strings are
not split in the middle of a double-byte character when output spans
record boundaries (as can happen in list-directed output).
.if '&cmpclass' eq 'load-n-go' .do begin
The compiler's run-time undefined variable checking routines will ignore
the second byte of a double-byte character (see the description of the
"check" option).
.do end
.*
.if '&cmpclass' ne 'load-n-go' .do begin
.*
.note [NO]COde
.ixm 'CODE option'
.ixm 'options' 'CODE'
:cmt. .ixm 'NOCODE option'
:cmt. .ixm 'options' 'NOCODE'
The "code" option causes the code generator to place character and
numeric constants in code segment.
Data generated for FORMAT statements will also be placed in the code
segment.
The default option is "nocode".
.*
.do end
.*
.if '&cmpclass' eq 'load-n-go' .do begin
.*
.note COdesize=n
.ixm 'CODESIZE option'
.ixm 'options' 'CODESIZE'
This option is used to control the maximum amount of memory that is to
be used for the object code of the source program.
.us n
must be an unsigned integer constant optionally followed by the letter
"k", in which case
.us n
is multiplied by 1024.
The amount of unused object memory is shown in the listing file
statistics as the "Object bytes free" statistic.
The default is 512k.
.*
.do end
.*
.if '&cmpclass' ne 'load-n-go' .do begin
.*
.note D1
.ixm 'D1 option'
.ixm 'options' 'D1'
Line number information is included in the object file ("type 1
debugging information").
.ix 'debugging' 'd1'
This option provides additional information to &dbgname (at the
expense of larger object files and executable files).
Line numbers are handy when debugging your application with &dbgname..
.*
.note D2
.ixm 'D2 option'
.ixm 'options' 'D2'
In addition to line number information, local symbol and data type
information is included in the object file ("type 2 debugging
information").
Although global symbol information can be made available to &dbgname
through a &lnkname option, local symbol and typing information must be
requested when the source file is compiled.
.ix 'debugging' 'd2'
This option provides additional information to &dbgname (at the
expense of larger object files and executable files).
However, it will make the debugging chore somewhat easier.
.*
.do end
.*
.if '&cmpclass' ne 'load-n-go' .do begin
.*
:CMT. .note [NO]DB
:CMT. .ixm 'DB option'
:CMT. .ixm 'options' 'DB'
:CMT. :cmt. .ixm 'NODB option'
:CMT. :cmt. .ixm 'options' 'NODB'
:CMT. The "db" option specifies that browsing information is to be emitted
:CMT. which can be used with the &brname..
:CMT. The browsing information is recorded in a file whose name is
:CMT. constructed from the source file name and the extension "MBR".
:CMT. The default option is "nodb".
.*
.do end
.*
.note [NO]DEBug
.ixm 'DEBUG option'
.ixm 'options' 'DEBUG'
:cmt. .ixm 'NODEBUG option'
:cmt. .ixm 'options' 'NODEBUG'
.if '&cmpclass' eq 'load-n-go' .do begin
This option is used to invoke the interactive debugger at execution time.
For more information on the interactive debugger, see the chapter
entitled "The &product Debugger".
The default is "nodebug".
.do end
.el .do begin
The "debug" option causes the generation of run-time checking code.
.ix 'debugging' 'bounds check'
.ix 'debugging' 'traceback'
This includes subscript and substring bounds checking as well as code
that allows a run-time traceback to be issued when an error occurs.
The default option is "nodebug".
.do end
.*
.note DEFine=<macro>
.ixm 'DEFINE=<macro> option'
.ixm 'options' 'DEFINE=<macro>'
.ix 'compiler directives' 'define'
This option is equivalent to specifying the following "define" compiler
directive.
.millust begin
*$define <macro>
.millust end
.pc
.ix 'macros'
The macro specified by the "define" option or compiler directive
becomes defined.
The definition status of the specified macro can be checked using the "ifdef",
"ifndef", "elseifdef" or "elseifndef" compiler directives.
.ix 'conditional compilation'
This allows source code to be conditionally compiled depending on the definition
status of the macro.
.ix 'macros' 'predefined'
.np
.ix 'predefined macros' '__i86__'
.ix __i86__
The macro
.mono __i86__
is a special macro that is defined by the compiler and identifies the
target as a 16-bit Intel 80x86 compatible environment.
.np
.ix 'predefined macros' '__386__'
.ix __386__
The macro
.mono __386__
is a special macro that is defined by the compiler and identifies the
target as a 32-bit Intel 386 compatible environment.
.np
.ix 'predefined macros' '__stack_conventions__'
.ix __stack_conventions__
The macro