Click above to get retro games delivered to your door ever month!

In this section, we present a terse summary of compiler options.  This
summary is displayed on the screen by simply entering the compiler command
name with no arguments.

Option:
    Description:

0
    (16-bit only) 8088 and 8086 instructions (see 0)

1
    (16-bit only) 188 and 186 instructions (see 1)

2
    (16-bit only) 286 instructions (see 2)

3
    (16-bit only) 386 instructions (see 3)

4
    (16-bit only) 486 instructions (see 4)

5
    (16-bit only) Pentium instructions (see 5)

6
    (16-bit only) Pentium Pro instructions (see 6)

3r
    (32-bit only) generate 386 instructions based on 386 instruction timings
    and use register-based argument passing conventions (see 3{r|s})

3s
    (32-bit only) generate 386 instructions based on 386 instruction timings
    and use stack-based argument passing conventions (see 3{r|s})

4r
    (32-bit only) generate 386 instructions based on 486 instruction timings
    and use register-based argument passing conventions (see 4{r|s})

4s
    (32-bit only) generate 386 instructions based on 486 instruction timings
    and use stack-based argument passing conventions (see 4{r|s})

5r
    (32-bit only) generate 386 instructions based on Intel Pentium
    instruction timings and use register-based argument passing conventions
    (x86 default) (see 5{r|s})

5s
    (32-bit only) generate 386 instructions based on Intel Pentium
    instruction timings and use stack-based argument passing conventions
    (see 5{r|s})

6r
    (32-bit only) generate 386 instructions based on Intel Pentium Pro
    instruction timings and use register-based argument passing conventions
    (x86 default) (see 6{r|s})

6s
    (32-bit only) generate 386 instructions based on Intel Pentium Pro
    instruction timings and use stack-based argument passing conventions
    (see 6{r|s})

bd
    build target is a Dynamic Link Library (DLL) (see bd)

bm
    build target is a multi-thread environment (see bm)

br
    build target uses DLL version of C/C++ run-time libraries (see br)

bt[=<os>]
    build target for operating system <os> (see bt[=<os>])

bw
    build target uses default windowing support (see bw)

d0
    (C++ only) no debugging information (see d0)

d1
    line number debugging information (see d1)

d1+
    (C only) line number debugging information plus typing information for
    global symbols and local structs and arrays (see d1+)

d2
    full symbolic debugging information (see d2)

d2i
    (C++ only) d2 and debug inlines; emit inlines as external out-of-line
    functions (see d2i)

d2s
    (C++ only) d2 and debug inlines; emit inlines as static out-of-line
    functions (see d2s)

d2t
    (C++ only) full symbolic debugging information, without type names (see
    d2t)

d3
    full symbolic debugging with unreferenced type names (see d3) ,*

d3i
    (C++ only) d3 plus debug inlines; emit inlines as external out-of-line
    functions (see d3i)

d3s
    (C++ only) d3 plus debug inlines; emit inlines as static out-of-line
    functions (see d3s)

d<name>[=text]
    preprocessor #define name [text] (see d<name>[=text])

d+
    allow extended -d macro definitions (see d+)

db
    generate browsing information (see db)

e<number>
    set error limit number (default is 20) (see e<number>)

ee
    call epilogue hook routine (see ee)

ef
    use full path names in error messages (see ef)

ei
    force enum base type to use at least an int (see ei)

em
    force enum base type to use minimum (see em)

en
    emit routine name before prologue (see en)

ep[<number>]
    call prologue hook routine with number of stack bytes available (see
    ep[<number>])

eq
    do not display error messages (they are still written to a file) (see
    eq)

et
    Pentium profiling (see et)

ew
    (C++ only) generate less verbose messages (see ew)

ez
    (32-bit only) generate Phar Lap Easy OMF-386 object file (see ez)

fc=<file_name>
    (C++ only) specify file of command lines to be batch processed (see
    fc=<file_name>)

fh[q][=<file_name>]
    use precompiled headers (see fh[q][=<file_name>])

fhd
    store debug info for pre-compiled header once (DWARF only) (see fhd)

fhr
    (C++ only) force compiler to read pre-compiled header (see fhr)

fhw
    force compiler to write pre-compiled header (see fhw)

fhwe
    (C++ only) don't include pre-compiled header warnings when "we" is used
    (see fhwe)

fi=<file_name>
    force file_name to be included (see fi=<file_name>)

fo=<file_name>
    set object or preprocessor output file specification (see
    fo[=<file_name>] (preprocessor)) (see fo[=<file_name>])

fpc
    generate calls to floating-point library (see fpc)

fpi
    (16-bit only) generate in-line 80x87 instructions with emulation
    (default)

    (32-bit only) generate in-line 387 instructions with emulation (default)
    (see fpi)

fpi87
    (16-bit only) generate in-line 80x87 instructions

    (32-bit only) generate in-line 387 instructions (see fpi87)

fp2
    generate in-line 80x87 instructions (see fp2)

fp3
    generate in-line 387 instructions (see fp3)

fp5
    generate in-line 80x87 instructions optimized for Pentium processor (see
    fp5)

fp6
    generate in-line 80x87 instructions optimized for Pentium Pro processor
    (see fp6)

fpd
    enable generation of Pentium FDIV bug check code (see fpd)

fpr
    generate 8087 code compatible with older versions of compiler (see fpr)

fr=<file_name>
    set error file specification (see fr[=<file_name>])
ft
    (C++ only) try truncated (8.3) header file specification (see ft)

fx
    (C++ only) do not try truncated (8.3) header file specification (see fx)

g=<codegroup>
    set code group name (see g=<codegroup>)

h{w,d,c}
    set debug output format (Watcom, Dwarf, Codeview) (see h{w,d,c})

i=<directory>
    add directory to list of include directories (see i=<directory>)

j
    change char default from unsigned to signed (see j)

k
    (C++ only) continue processing files (ignore errors) (see k)

m{f,s,m,c,l,h}
    memory model - mf=flat (see mf), ms=small (see ms), mm=medium (see mm),
    mc=compact (see mc), ml=large (see ml), mh=huge (see mh) (default is
    "ms" for 16-bit and Netware, "mf" for 32-bit)

nc=<name>
    set name of the code class (see nc=<name>)

nd=<name>
    set name of the "data" segment (see nd=<name>)

nm=<name>
    set module name different from filename (see nm=<name>)

nt=<name>
    set name of the "text" segment (see nt=<name>)

o{a,b,c,d,e,f,f+,h,i,i+,k,l,l+,m,n,o,p,r,s,t,u,x,z}
    control optimization (see oa)

p{e,l,c,w=<num>}
    preprocess file only, sending output to standard output; "c" include
    comments; "e" encrypt identifiers (C++ only); "l" include #line
    directives; w=<num> wrap output lines at <num> columns (zero means no
    wrap) (see p{e,l,c,w=<num>})

r
    save/restore segment registers (see r)

ri
    return chars and shorts as ints (see ri)

s
    remove stack overflow checks (see s)

sg
    generate calls to grow the stack (see sg)

st
    touch stack through SS first (see st)

t=<num>
    (C++ only) set tab stop multiplier (see t=<num>)

u<name>
    preprocessor #undef name (see u<name>)

v
    output function declarations to .def file (with typedef names) (see v)

w<number>
    set warning level number (default is w1) (see w<number>)

wcd=<num>
    (C++ only) warning control:  disable warning message <num> (see
    wcd=<number>)

we
    treat all warnings as errors (see we)

wo
    (C only) (16-bit only) warn about problems with overlaid code (see wo)

wx
    set warning level to maximum setting (see wx)

xd
    (C++ only) disable exception handling (default) (see xd)

xdt
    (C++ only) disable exception handling (same as "xd") (see xdt)

xds
    (C++ only) disable exception handling (table-driven destructors) (see
    xds)

xs
    (C++ only) enable exception handling (see xs)

xst
    (C++ only) enable exception handling (direct calls for destruction) (see
    xst)

xss
    (C++ only) enable exception handling (table-driven destructors) (see
    xss)

z{a,e}
    disable/enable language extensions (default is ze) (see za) (see ze)

zc
    place literal strings in code segment (see zc)

zd{f,p}
    allow DS register to "float" or "peg" it to DGROUP (default is zdp) (see
    zd{f,p})

zdl
    (32-bit only) load DS register directly from DGROUP (see zdl)

zf{f,p}
    allow FS register to be used (default for all but flat memory model) or
    not be used (default for flat memory model) (see zf{f,p})

zg
    output function declarations to .def (without typedef names) (see zg)

zg{f,p}
    allow GS register to be used or not used (see zg{f,p})

zk0
    double-byte char support for Kanji (see zk{0,1,2,l})

zk0u
    translate Kanji double-byte characters to UNICODE (see zk0u)

zk1
    double-byte char support for Chinese/Taiwanese (see zk{0,1,2,l})

zk2
    double-byte char support for Korean (see zk{0,1,2,l})

zkl
    double-byte char support if current code page has lead bytes (see
    zk{0,1,2,l})

zku=<codepage>
    load UNICODE translate table for specified code page (see
    zku=<codepage>)

zl
    suppress generation of library file names and references in object file
    (see zl)