VisualAge C++ includes both an incremental compiler that replaces the traditional C++ compiler supplied in earlier versions of the product, and a C compiler. The old form of options are no longer used. For both C and C++, you control the compile and link stages of build by specifying options in a configuration file.
The syntax of configuration file options indicates whether the option relates to code generation, optimization, the C or C++ language, the link stage, or other features of builds.
The table below gives the configuration file option equivalent to compile options from earlier versions of VisualAge C++ and predecessor products. In an incremental C++ compile, not all the old options are meaningful, some are automatic, and the functionality of others is provided in a different way. An entry of N/A in the table indicates that an equivalent new option is not available. In this version of VisualAge C++, some options may apply to only one of C or C++ code, but not both. Option applicability is indicated in the description column.
In the option syntax, the characters [ and ] enclose optional items, and the character | indicates alternatives. For example, /Fm[+|-] is equivalent to /Fm+, /Fm-, or /Fm.
| Old Option | Description | Configuration File Option |
|---|---|---|
| /? | Display help | N/A |
| /B"options" | Pass options to linker | link options |
| /C[+|-] | Perform compile without linking | N/A |
| /Dname Dname=[value] |
Define preprocessor macro. | define(macro_name[, string]) |
| /Fa[+|-][dir][name] | file(genAsm[,
yes]) file(genAsm, no) file(asmFileName, String) |
|
| /Fb[+|-|*] | Produce a browser file | N/A |
| /Fc[+|-] | file(syntaxOnly[,
yes]) file(syntaxOnly, no) |
|
| /Fename | Specify name of executable output file | target [exe] fileName |
| /Fi[+|-][dir][name] | file(genPCH[,
yes]) file(genPCH, fileName) file(genPCH, no) |
|
| /Fl[+|-][dir][name] | list(listing[,
yes]) list(listing, no) list(fileName, string) |
|
/Fm[+|-] /Fmname |
Produce a linker map file | link(map[,
yes]) link(map, no) link(map, name) |
/Fn[+|-] /Fn[dir][name] |
file(genAsmWithCode[
,yes]) file(genAsmWithCode, fileName) file(genAsmWithCode, no) |
|
| /Fo[+|-][dir][name] | file(genObject[,
yes]) file(genObject, fileName) file(genObject, no) |
|
| /Ft[+|-][dir] | Control and direct files for template resolution | N/A |
| /Fw[+|-][dir][name] | Create intermediate code files only | N/A |
| /G3 /G4 /G5 |
Specify the processor for which the code is optimized | opt(tune, processor) |
| /Ga | Turn on implicit SOM mode | N/A |
| /Gb | Disable direct access to attributes for DSOM | N/A |
| /Gd[+|-] | Dynamically link to the runtime library, instead of linking statically | link(linkWithSharedLib[,
yes]) link(linkWithSharedLib, no) |
| /Ge[+|-] | Build .exe or .dll file | target [type] fileName |
| /Gf[+|-] | Use fast floating-point execution. | opt(float[,
yes]) opt(float, no) |
| /Gh[+|-] | Enable code for performance analysis | gen(profile[,
yes]) gen(profile, no) |
| /Gi[+|-] | Use fast integer execution | opt(integer[,
yes]) opt(integer, no) |
| /Gk[+|-] | Support objects generated with C Set ++ and containing templates | N/A |
| /Gl[+|-] | Remove unreferenced functions | gen(unreferenced[,
yes]) gen(unreferenced, no) |
| /Gm[+|-] | Link with the multithread library, instead of the single-thread library | link(linkWithMultiThreadLib[,
yes]) link(linkWithMultiThreadLib, no) |
| /Gn[+|-] | Hide default library information from linker | link(defaultLibs[,
yes] link(defaultLibs, no) |
| /Gp[+|-] | Support parmdwords | gen(parmDWord[,
yes] gen(parmDWord, no) |
| /Gr[+|-] | Generate code to run on ring 0 | gen(ring0[,
yes] gen(ring0, no) |
| /Gs[+|-] | Support stack probes | gen(probe[,
yes] gen(probe, no) |
| /Gt[+|-] | Support tiled memory for 16-bit code | gen(tiledMemory[,
yes] gen(tiledMemory, no) |
| /Gu[+|-] | Stop external functions from using data defined in intermediate files | N/A |
| /Gv[+|-] | gen(loadDS[,
yes] gen(loadDS, no) |
|
| /Gw[+|-] | N/A | |
| /Gx[+|-] | gen(eh[,
yes] gen(eh, no) |
|
| /Gy[+|-] | Decorate all external data names with leading underscore | gen(decorateExternalNames[,
yes] gen(decorateExternalNames, no) |
| /Gz[+|-] | Prebuild SOM classes | N/A |
| /Hnum | Set maximum length of external names | |
| /Ipath[;path] | Specify #include search paths | incl(searchPath, path) |
| /J[+|-] | Treat unspecified char variables as signed char | lang(signedChars[,
yes] lang(signedChars, no) |
| /L[+|-] | list(listing[,
yes] list(listing, no) |
|
| /La[+|-] | list(refStructVar[,
yes] list(refStructVar, no) |
|
| /Lb[+|-] | list(allStructVar[,
yes] list(allStructVar, no) |
|
| /Le[+|-] | list(expMacros[,
yes] list(expMacros, no) |
|
| /Lf[+|-] | list(full[,
yes] list(full, no) |
|
| /Li[+|-] | list(expusrinc[,
yes] list(expusrinc, no) |
|
| /Lj[+|-] | list(expAllInc[,
yes] list(expAllInc, no) |
|
| /Lpnumber | list(pageLen, number) | |
| /Ls[+|-] | list(incSource[,
yes] list(incSource, no) |
|
| /Lt"string" | list(title, string) | |
| /Lu"string" | list(subTitle, string) | |
| /Lx[+|-] | list(minXRef[,
yes] list(minXRef, no) |
|
| /Ly[+|-] | list(fullXRef[,
yes] list(fullXRef, no) |
|
| /Mp /Ms /Mc /Mt |
Set default calling convention | gen(call,
optlink) gen(call, system) gen(call, cdecl) gen(call, stdcall) |
| /Nnumber | debug(maxerror, number) | |
| /Ndname | Set names of default data, uninitialized data, and constant segments | gen(dataSeg,
name) gen(uninitSeg, name) gen(constSeg, name) |
| /Ntname | Set names of default code or data segment | gen(codeSeg, name) |
| /Nxname | gen(ehCodeSeg,
name) gen(ehDataSeg, name) |
|
| /O[+|-|2|3|4] | Optimize code for speed. | opt(level, level) |
| /Oc[+|-] | Optimize code for size. | opt(size[,
yes]) opt(size, no) |
| /Oi[+|-] | Inline specified user functions | opt(inline[,
yes]) opt(inline, no) opt(autoInline[, yes]) opt(autoInline, no) |
| /Ol[+|-] | Use intermediate code linker | N/A |
| /Om[+|-] | opt(limitWorkingSet[,
yes]) opt(limitWorkingSet, no) |
|
| /Op[+|-] | Perform optimizations that involve the stack pointer | opt(stackPointer[,
yes]) opt(stackPointer, no) |
| /Oq[+|-] | Control stack chaining. | opt(stackChaining[,
yes]) opt(stackChaining, no) |
| /Os[+|-] | Invoke the instruction scheduler | opt(schedule[,
yes]) opt(schedule, no) |
| /P[+|-] | pp(preprocessOnly[,
yes]) pp(preprocessOnly, no) |
|
| /Pc[+|-] | pp(preserveComments[,
yes]) pp(preserveComments, no) |
|
| /Pd[+|-] | pp(stdout[,
yes]) pp(stdout, no) |
|
| /Pe[+|-] | pp(suppressLine[,
yes]) pp(suppressLine, no) |
|
| /Q[+|-] | N/A | |
| /qalias | Specify which aliasing rules can be used during optimization | opt(alias,
allp) opt(alias, typ) opt(alias, addr) opt(alias, ansi) |
| /qarch | Specify target CPU architecture | opt(arch, CPUtype) |
| /qautoimported /qnoautoimported | gen(import[,
yes]) gen(import, no) |
|
| /qautothread /qnoautothread | N/A | |
| /qbitfields=signed /qbitfields =unsigned |
Specify default sign of bitfields | gen(signedBitfields[,
yes]) gen(signedBitfields, no) |
| /qdbgunref /qnodbgunref | Use referenced and unreferenced symbols during debugging | gen(debugUnreferenced[,
yes]) gen(debugUnreferenced, no) |
| /qdigraph /qnodigraph |
Permit standard digraph and keyword operators | |
| /qignerrno | Tell the optimizer that the program will never refer to or set errno | lang(ignerrno[,
yes]) lang(ignerrno, no) |
| /qignprag=disjoint /qignprag=isolated /qignprag=all |
Ignore references to #pragma disjoint and #pragma isolated_call | opt(pragmaDisjoint[,
yes]) opt(pragmaDisjoint, no) opt(pragmaIsolatedCall[, yes]) opt(pragmaIsolatedCall, no) |
| /qinitauto | Initialize automatic storage | gen(initAuto[,
yes]) gen(initAuto, number) gen(initAuto, no) |
| /qipa | N/A | |
| /qisolated_call =fname[:fname]... | List functions that do not change data objects at time of function call | opt(isolatedCall, string) |
| /qlibansi /qnolibansi |
Process standard C library names as system functions | gen(libANSI[,
yes]) gen(libANSI, no) |
| /qlonglong /qnolonglong | Process or disallow type long long int | lang(longLong[,
yes]) lang(longLong, no) |
| /qmakedep | file(makeDep[, yes]) | |
| /qro /qnoro |
Use read-only, or read-write storage for string literals | gen(readOnly[,
yes]) gen(readOnly, no) |
| /qrtti=rtoption /qnortti |
Generate information for run-time type information | N/A |
| /qsomvolattr /qnosomvolattr | Use volatile on attribute prototypes | N/A |
| /qtune=option | Specify the processor for which code is optimized | opt(tune, processor) |
| /qwin32s /qnowin32s |
N/A | |
| /R[e|n] | Generate code that can be used as a subsystem without a runtime environment. | link(standAlone[,
yes]) link(standAlone, no) |
| /Sa /Se /S2 |
lang(level,
ansi) lang(level, extended) lang(level, saa12) |
|
| /Sc | Set C++ language level. | N/A |
| /Sd[+|-] | Set the default file extension for source files to .c, instead of .obj | N/A |
| /Sg[left][,right|*] /Sg[-] | misc(margins[,
yes]) misc(margins, no) misc(marginValues, left[, right]) |
|
| /Sh[+|-] | lang(ddNames[,
yes]) lang(ddNames, no) |
|
| /Si[+|-] /Si[dir][filename] |
file(usePCH[,
yes]) file(usePCH, fileName) file(usePCHl, no) |
|
| /Sm[+|-] | lang(ignObsoleteKeywords[,
yes]) lang(ignObsoletekeywords, no) |
|
| /Sn[+|-] | lang(dbcs[,
yes]) lang(dbcs, no) |
|
| /Sp[1|2|4|8|16] | Specify alignment or packing of data items within structures and unions | gen(pack, number) |
| /Sq[left][, right] /Sq[left][, *] /Sq[-] |
misc(sequenceNumbers[,
yes]) misc(sequenceNumbers, no) misc(sequenceNumberValues, left[, right]) |
|
| /Sr[+|-] | lang(preserveUnsignedPromotion[,
yes]) lang(preserveUnsignedPromotion, no) |
|
| /Ss[+|-] | lang(slashSlashComments[,
yes]) lang(slashSlashComments, no) |
|
| /Su[+|-|1|2|4] | Control size of enum variables | gen(enumSize,
int) gen(enumSize, small) gen(enumSize, bytes) |
| /Sv[+|-] | lang(memoryFiles[,
yes]) lang(memoryFiles, no) |
|
| /Tcfilename | Compile as a C source file, regardless of extension | N/A |
| /Td[c|p] | Specify the default language for sourc files, overriding extension | N/A |
| /Ti[+|-] | gen(debug[,
yes]) gen(debug, no) |
|
| /Tm[+|-] | Enable debug version of memory management functions | alloc(debug[,
yes]) alloc(debug, no) |
| /Tn[+|-] | gen(lineOnlyDebug[,
yes]) gen(lineOnlyDebug, no) |
|
| /Tpfilename | Compile as a C++ source file, regardless extension | N/A |
| /Tx[+|-] | Provide a complete machine-state dump when an exception occurs, instead of providing only the exception message and address | gen(dump[,
yes]) gen(dump, no) |
| /Uname /U* |
Undefine macros | undefine(macro_name) |
| /V"string" | Include a version string in the object and executable files | link(versionString, string) |
| /W0 /W1 /W2 /W3 |
Set minimum severity level of messages the compiler produces and counts | report(level,
E) report(level, W) report(level, I) |
| /Wgroup[+|-][group] | info(group[,
yes]) info(group, no) info(all[, yes]) info(all, no) |
|
| /Xc[+|-] | file(ignoreusrincpaths[,
yes]) file(ignoreusrincpaths, no) |
|
| /Xi[+|-] | file(ignoreEnvIncPaths[,
yes]) file(ignoreEnvIncPaths, no) |
![]()
Incremental C++ Build
C Compilation
Configuration
Files
![]()
Link Options from Earlier Versions of
VisualAge C++
Build Options
Build Options for Compliance With the C++
Standard
Build Options for Compatibility with Old
C++ Compilers
