Comeau C/C++ 4.x
User-Documentation
- Command Line Driver Program
This document describes the interface to the command line driver.
Additional options for recent updates of Comeau C/C++ can be found at http://www.comeaucomputing.com/features.html.
The command line driver is invoked by a command of the form
como [options] ifile
to compile
the single input file ifile.
Various file name suffixes are allowed on input files including .c, .C, .cc, .cpp, .CPP, .cxx, and .CXX. On a limited numer of platforms, some other suffixes might be allowed. And of course, object file or library extensions such as .o, .obj, .OBJ, .a, .lib or .LIB are ok, and usually follow the naming conventions for the respective platform being used.
On a limited number of platforms, if - (hyphen) is
specified for ifile, stdin will be used as the input file.
Command
line options may be specified using either single character option
codes (e.g., -o) or keyword options (e.g., --output), depending upon the option type.
A single character option specification consists of a hyphen followed
by one or more option characters (e.g., -Ab). If an option
requires an argument, the argument may immediately follow the
option letter, or may be separated from the option letter by white
space.
A keyword option specification consists of two hyphens
followed by the option keyword (e.g., --strict). If an
option requires an argument, the argument may be separated from
the keyword by white space, or the keyword may be immediately
followed by =option. When the second form is used
there may not be any white space on either side of the equal
sign.
Note: the MS-Windows port may not work this way in all cases, nor may it support all options and behavior discussed below.
For instance, with Comeau C/C++ for MS-Windows there must be an equal sign where some of the options below allow spaces, and furthermore, there can be no spaces before or after the equal sign. Check out the "Windows specific" page for more details. Information on using STLFilt with Comeau C++ on MS-Windows can also be found at the end of that page.
A
list of files may appear for ifile. If a list of files
is specified, options that specify a compilation output file (--output,
--list, and --xref) may not be used, and the
name of each source file is usually written to stderr as the
compilation of that file begins.
Note: This capability is not
the default, and would need to be activated under a custom porting
arrangement.
When one of the preprocessing-only modes is specified
(see below), the --output option can be used to specify
the preprocessing output file. If --output is not specified,
preprocessing output is written to stdout. Preprocessing
output has trigraphs and line splices processed (and thus they
do not appear in their original form).
When compilation (rather
than just preprocessing) is done, the output (if any) from the
compilation is written to a file selected by the back end, such
as x.o or x.obj; see the documentation of the
back end for further information. For versions of the front end
that generate an intermediate language file, the --output
option can be used to specify the IL output file (note: this capability is not
the default, and would need to be activated under a custom porting
arrangement).
The options follow below.
Additional options for recent updates of Comeau C/C++ can be found at http://www.comeaucomputing.com/features.html.
Note that whether strict mode (see below) is the default or not depends upon how you installed Comeau C++, at least for UNIX platforms. Under Windows, the default mode is not strict mode, and furthermore is --microsoft, which allows compatibility with the MS header files. For most platforms, when you invoke Comeau C++, it will tell you what mode it is in.
--preprocess
-E Do
preprocessing only. Write preprocessed text to the preprocessing
output file, with comments removed and with line control information.
-c Compile only. Do not link. Instiantiate only those templates directly "owned" by this file.
Do not confuse this with the --c (note two dashes not one) option which specificies C90 mode.
So if you want to compile and link a C90 source you'd write: como --c c.c
and to compile but not link a C90 source you'd write: como -c --c c.c or como --c -c c.c
and so on.
--no_line_commands
-P
Do preprocessing only. Write preprocessed text to the preprocessing
output file, with comments removed and without line control information.
--comments
-C
Keep comments in the preprocessed output. This should be
specified after either --preprocess or --no_line_commands;
it does not of itself request preprocessing output.
--old_line_commands
When generating source output (e.g., with the C-generating
back end), put out #line directives in the form used
by the Reiser cpp, i.e., "# nnn" instead
of "#line nnn".
--dependencies
-M
Do preprocessing only. Instead of the normal preprocessing
output, generate on the preprocessing output file a list of dependency
lines suitable for input to the UNIX make program. Note
that when implicit inclusion of templates is enabled, the output
may indicate false (but safe) dependencies unless --no_preproc_only is also used.
--trace_includes
-H
Do preprocessing only. Instead of the normal preprocessing
output, generate on the preprocessing output file a list of the
names of files #included.
--define_macro name [ = def ]
-D name
[ = def ] Define macro name as def.
If "= def " is omitted, define name
as 1.
--undefine_macro
name
-Uname Remove any initial definition
of the macro name. --undefine_macro options are
processed after all --define_macro options in the command
line have been processed.
--include_directory dir
-Idir
Add dir to the list of directories searched for #includes.
Files whose names are not absolute pathnames and that are enclosed
in "..." will be searched for in the following
directories, in the order listed:
- The directory containing the current input file (the primary
source file or the file containing the #include);
- Any directories specified in --include_directory
options (in the order in which they were listed on the command
line);
- Any directories on the standard list (this list is selected
at the time of installation of the front end; often, it is just
the one directory /usr/include or a similar system include
directory for C++).
For file names enclosed in <...>,
only the directories that are specified using the --include_directory
option and those on the standard list are searched. If dir
is specified as "-", e.g., "-I-",
the option indicates the point in the list of --include_directory
options at which the search for file names enclosed in <...>
should begin. That is, the search for <...> names
should only consider directories named in --include_directory
options following the -I-, and the directories of item
3 above. -I- also removes the directory containing the
current input file (item 1 above) from the search path for file
names enclosed in "...".
--output ofile
-o
ofile Specifies the output file of the compilation,
i.e., the preprocessing or executable file. On many platforms, -o can be used to name the object file.
--version
-v
Display the version number of the front end, and the Comeau
Computing copyright.
On most platforms, this requires a file name to be specified as well.
--no_code_gen
-n Do syntax-checking
only, i.e., do not run the back end.
--no_warnings
-w Suppress warnings. Errors
are still issued.
--remarks
-r Issue remarks, which
are diagnostic messages even milder than warnings.
--error_limit
number
-e number Set the error limit
to number. The front end will abandon compilation after
this number of errors (remarks and warnings are not counted toward
the limit). By default, the limit is 100.
--diag_suppress
tag,tag,...
--diag_remark tag,tag,...
--diag_warning tag,tag,...
--diag_error
tag,tag,... Override the normal error severity of
the specified diagnostic messages. The message(s) may be specified
using a mnemonic error tag or using an error number. The error
tag names and error numbers can be found by using the --display_error_number option. Note that although in general you can increase or decrease
the severity of most diagnostics, some diagnostics are so severe that they
may not have their severity altered.
Those which can have their severities altered will have a -D appended to the error number. So, if --display_error_number were to display 111-D as the error number, then error number 111 is able to be altered to a different severity, say with --diag_suppress=111 (note that you don't use the -D), while an error number of 20 should not be altered.
--display_error_number
Display the error message number in any diagnostic messages that
are generated. The option may be used to determine the error number
to be used when overriding the severity of a diagnostic message.
As noted above, a -D suffix appearing with the error message
means that the severity may be altered.
If there is no -D suffix on the error number, then you cannot alter its severity, meaning, for instance, you should not use --diag_suppress=20 as it does not display as 20-D.
--no_use_before_set_warnings
-j Suppress warnings on local
automatic variables that are used before their values are set.
The front end's algorithm for detecting such uses is conservative
and is likely to miss some cases that an optimizer with sophisticated
flow analysis could detect; thus, an implementation might choose
to suppress the warnings from the front end when optimization
has been requested but to permit them when the optimizer is not
being run.
--c++
-p Enable compilation of C++. This is the default.
--c
-m Enable compilation of C (C90) rather than C++.
--c99
Enable compilation of C99 rather than C90 or C++.
--old_c
-K
Enable K&R/pcc mode, which approximates the behavior
of the standard UNIX pcc. ANSI C features that do not
conflict with K&R/pcc features are still supported in this
mode.
--strict_warnings or -a
--strict
or -A Enable strict ANSI mode, which
provides diagnostic messages when non-ANSI features are used,
and disables features that conflict with ANSI C or C++. This is
compatible with C90, C99 and C++ mode (although ANSI conformance
with C++ does not yet mean anything). It is not compatible with
pcc mode. ANSI violations can be issued as either warnings or
errors depending on which command line option is used. The -A
and --strict options cause errors to be issued whereas
the -a and --strict_warnings options produce
warnings. The error threshold is set so that the requested diagnostics
will be listed.
--anachronisms
--no_anachronisms Enable or disable anachronisms in C++
mode. The default for this option is to
not allow them (this can be changed under a custom porting arrangement).
This option is valid only in C++ mode.
--cfront_2.1
-b Enable compilation of C++ with compatibility with
cfront version 2.1. This causes the compiler to accept language
constructs that, while not part of the C++ language definition,
are accepted by the AT&T C++ Language System (cfront) release
2.1. This option also enables acceptance of anachronisms.
--cfront_3.0 Enable compilation of C++ with compatibility
with cfront version 3.0. This causes the compiler to accept language
constructs that, while not part of the C++ language definition,
are accepted by the AT&T C++ Language System (cfront) release
3.0. This option also enables acceptance of anachronisms.
--signed_chars
-s
Make plain char signed. The default signedness for
char is selected at the time of installation of the front
end (information on this appears in a later section of this document).
When plain char is signed, the macro __SIGNED_CHARS__
is defined by the front end.
--unsigned_chars
-u Make
plain char unsigned. The default signedness for char
is selected at the time of installation of the front end (information
on this appears in a later section of this document).
--suppress_vtbl
-V Suppress definition of virtual function tables in
cases where the heuristic used by the front end to decide on definition
of virtual function tables provides no guidance. The virtual function
table for a class is defined in a compilation if the compilation
contains a definition of the first non-inline non-pure virtual
function of the class. For classes that contain no such function,
the default behavior is to define the virtual function table (but
to define it as a local static entity). The option --suppress_vtbl
suppresses the definition of the virtual function tables for such
classes, and --force_vtbl forces the definition of the
virtual function table for such classes. --force_vtbl
differs from the default behavior in that it does not force the
definition to be local. This option is valid only in C++ mode.
--force_vtbl Force definition of virtual function tables
in cases where the heuristic used by the front end to decide on
definition of virtual function tables provides no guidance. See
--suppress_vtbl. This option is valid only in C++ mode.
--instantiate
mode
-tmode Control instantiation
of external template entities. External template entities are
external (i.e., noninline and nonstatic) template functions and
template static data members. The instantiation mode determines
the template entities for which code should be generated based
on the template definition):
none Instantiate no template
entities. This is the default.
used Instantiate only
the template entities that are used in this compilation.
all
Instantiate all template entities whether or not they are used.
local
Instantiate only the template entities that are used in this
compilation, and force those entities to be local to this compilation.
See the section of this chapter on template instantiation. This
option is valid only in C++ mode.
--auto_instantiation
--no_auto_instantiation
-T Enable or disable automatic instantiation of templates.
The -T option is equivalent to --auto_instantiation.
The default behavior .is
to allow automatic instantiation (this can be changed under a
custom porting arrangement). See the section of this chapter on
template instantiation. This option is valid only in C++ mode.
--implicit_include
--no_implicit_include
-B Enable or disable implicit inclusion of source files
as a method of finding definitions of template
entities to be instantiated. -B is equivalent to
--implicit_ include. See the section of this
chapter on
template instantiation. This option is valid only in C++ mode.
--suppress_instantiation_flags
When automatic instantiation is being used, this option suppresses
the generation of the special symbols used by the prelinker to
do automatic instantiation processing. This option is for use
by the driver and prelinker and should not be used directly by
users. This option is used to implement the driver option that
removes the instantiation flags from object files once the prelinking
step has completed.
--distinct_template_signatures
--no_distinct_template_signatures
Control whether the signatures for template functions can match
those for non- template functions when the functions appear in
different compilation units. (This option is available only on
versions that do name mangling on the names of external entities.)
The default is
--distinct_template_signatures, under
which a normal function cannot be used to satisfy the need for
a template instance; e.g, a function "void f(int)"
could not be used to satisfy the need for an instantiation of
a template "void f(T)" with T set
to int. --no_ distinct_template_signatures provides
the older language behavior, under which a non-template function
can match a template function.
--exceptions
--no_exceptions
-x Enable or disable support for exception handling.
-x is equivalent to --exceptions. The default
behavior for
the front-end (but not for the command line driver) is for exceptions
to be disabled (this can be changed under a custom porting arrangement).
This option is valid only in C++ mode.
--rtti
--no_rtti Enable or disable support for RTTI (runtime
type information) features: dynamic_cast, typeid.
The default behavior is
for RTTI to be enabled (this can be changed under a custom porting
arrangement). This option is valid only in C++ mode.
--array_new_and_delete
--no_array_new_and_delete
Enable or disable support for array new and delete. The default
behavior is for
array new and delete to be enabled (this can be change under a
custom porting arrangement). This option is valid only in C++
mode. The front end can be configured to define a preprocessing
variable when array new and delete are enabled. This preprocessing
variable may then be used by the standard header files to decide
whether to include the declarations for the array new/delete functions.
--explicit
--no_explicit Enable or disable support for the explicit
specifier on constructor declarations. The default behavior is
for
explicit to be enabled (this can be changed under a custom
porting arrangement). This option is valid only in C++ mode.
--namespaces
--no_namespaces Enable or disable support for namespaces.
The default behavior is for
namespaces to be enabled (this can be changed under a custom porting
arrangement). This option is valid only in C++ mode.
--using_std
--no_using_std Enable or disable implicit use of the
std namespace when standard header files are included.
The default behavior is for
this to be disabled (this can be changed under a custom porting
arrangement). This option is valid only in C++ mode.
--old_for_init
--new_for_init Control the scope of a declaration in
a for-init-statement. The old (cfront-compatible) scoping
rules mean the declaration is in the scope to which the for
statement itself belongs; the new (standard-conforming) rules
in effect wrap the entire for statement in its own implicitly
generated scope. The default behavior is the
new rules (this can be changed under a custom porting arrangement), unless --microsoft is specified.
This option is valid only in C++ mode.
--for_init_diff_warning
--no_for_init_diff_warning
Enable or disable a warning that is issued when programs compiled
under the new for-init scoping rules would have had different
behavior under the old rules. The diagnostic is only put out when
the new rules are used. The
default behavior is to emit this diagnostic (this can be changed
under a custom porting arrangement). This option is valid only
in C++ mode.
--old_specializations
--no_old_specializations
Enable or disable acceptance of old-style template specializations
(i.e., specializations that do not use the template<>
syntax). Default behavior is that
old specializations are allowed (this can be changed under a custom
porting arrangement). This option is valid only in C++ mode.
--implicit_extern_c_type_conversion
--no_implicit_extern_c_type_conversion
Enable or disable an extension to permit implicit type conversion
in C++ between a pointer to an extern "C" function
and a pointer to an extern "C++" function.
This extension is allowed in environments where C and C++ functions
share the same calling conventions: Hence,
by default (this can be changed in under a custom porting arrangement)
this extension is enabled. (It is useful, for instance, for cfront
compatibility -
in standard C++ the linkage specification is part of the function
type, with the consequence that otherwise identical function types,
one declared extern "C" and the other declared
extern "C++", are viewed as distinct.)
--long_preserving_rules
--no_long_preserving_rules
Enable or disable the K&R usual arithmetic conversion rules
with respect to long. This means the rules of K&R
I, Appendix A, 6.6, not the rules used by the pcc compiler. The
significant difference is in the handling of "long
op unsigned int" when int and long
are the same size. The ANSI/ISO/pcc rules say the result is unsigned
long, but K&R I says the result is long (unsigned
long did not exist in K&R I).
--extern_inline
--no_extern_inline Enable or disable
support for inline functions with external linkage in
C++. When inline functions are allowed to have external
linkage (as required by the standard), then extern and
inline are compatible specifiers on a nonmember function
declaration; the default linkage when inline appears
alone is external (i.e., inline means extern inline
on nonmember functions); and an inline member function
takes on the linkage of its class (which is usually external).
However, when inline functions have only internal linkage
(as specified in the ARM), then extern and inline
are incompatible; the default linkage when inline appears
alone is internal (i.e., inline means static inline
on nonmember functions); and inline member functions
have internal linkage no matter what the linkage of their class.
--module_init name1,name2,...
-iname1,name2,... When compiling
in C mode, and if the current compilation contains a main
program, force calling of the file-scope initialization routines
in the indicated compiled units. This is needed only when there
are file-scope union initializations in translation units that
do not contain a main program. A message will be issued during
compilation of such units, indicating the need for the --module_init
option. All necessary names must be specified in one --module_init
option; a second --module_init will overwrite the original
list, not add to it. This option is not needed when object code
is generated by a back end other than the C-generating back end,
nor is it needed when the C-generating back end is configured
to generate ANSI C. This option is not needed in C++ mode, because
C++ has a language mechanism for getting initialization code executed
at program start-up.
--dollar
-$ Accept dollar
signs in identifiers. The default value of this option is specified
in a configuration file.
--error_output efile Redirect
the output that would normally go to stderr (i.e., diagnostic
messages) to the file efile. This option is useful on systems
where output redirection of files is not well supported. If used,
this option should probably be specified first in the command
line, since otherwise any command-line errors for options preceding
the --error_output would be written to stderr
before redirection.
--xref xfile
-Xxfile
Generate cross-reference information in the file xfile.
For each reference to an identifier in the source program, a line
of the form
symbol-id name ref-code file-name line-number column-number
is written, where ref-code is D for definition,
d for declaration (that is, a declaration that is not
a definition), M for modification, A for address
taken, U for used, C for changed (but actually
meaning "used and modified in a single operation," such
as an increment), R for any other kind of reference,
or E for an error in which the kind of reference is indeterminate.
symbol-id is a unique decimal number for the symbol. The
fields of the above line are separated by tab characters.
--list
lfile
-Llfile Generate raw listing
information in the file lfile. This information is likely
to be used to generate a formatted listing. The raw listing file
contains raw source lines, information on transitions into and
out of include files, and diagnostics generated by the front end.
Each line of the listing file begins with a key character that
identifies the type of line, as follows:
N: a
normal line of source; the rest of the line is the text of the
line.
X: the expanded form of a normal line
of source; the rest of the line is the text of the line. This
line appears following the N line, and only if the line
contains non-trivial modifications (comments are considered trivial
modifications; macro expansions, line splices, and trigraphs are
considered non-trivial modifications).
S: a
line of source skipped by an #if or the like; the rest
of the line is text. Note that the #else, #elif,
or #endif that ends a skip is marked with an N.
L:
an indication of a change in source position. The line has
a format similar to the # line-identifying directive
output by cpp, that is to say
L line-number "file-name"
key
where key is 1 for entry into an include
file, 2 for exit from an include file, and omitted otherwise.
The first line in the raw listing file is always an L
line identifying the primary input file. L lines are
also output for #line directives (key is omitted).
L lines indicate the source position of the following
source line in the raw listing file.
R, W,
E, or C:
an indication
of a diagnostic (R for remark, W for warning,
E for error, and C for catastrophic error).
The line has the form
S "file-name"
line-number column-number message-text
where S is
R, W, E, or C, as explained
above. Errors at the end of file indicate the last line of the
primary source file and a column number of zero. Command-line
errors are catastrophes with an empty file name ("")
and a line and column number of zero. Internal errors are catastrophes
with position information as usual, and message-text beginning
with (internal error). When a diagnostic displays a
list (e.g., all the contending routines when there is ambiguity
on an overloaded call), the initial diagnostic line is followed
by one or more lines with the same overall format (code letter,
file name, line number, column number, and message text), but
in which the code letter is the lower case version of the code
letter in the initial line. The source position in such lines
is the same as that in the corresponding initial line.
--timing
-#
Generate compilation timing information. This option causes
the compiler to display the amount of CPU time and elapsed time
used by each phase of the compilation and a total for the entire
compilation.
--pch Automatically use and/or create a precompiled
header file - for details, see the "Precompiled Headers"
section in this chapter. If --use_pch or --create_pch
(manual PCH mode) appears on the command line following this option,
its effect is erased.
--create_pch file-name If
other conditions are satisfied (see the "Precompiled Headers"
section), create a precompiled header file with the specified
name. If --pch (automatic PCH mode) or --use_pch
appears on the command line following this option, its effect
is erased.
--use_pch file-name Use a precompiled
header file of the specified name as part of the current compilation.
If --pch (automatic PCH mode) or --create_pch appears
on the command line following this option, its effect is erased.
--pch_dir
directory-name The directory in which to search for
and/or create a precompiled header file. This option may be used
with automatic PCH mode (--pch) or with manual PCH mode
(--create_pch or --use_pch).
--pch_messages
--no_pch_messages
Enable or disable the display of a message indicating that
a precompiled header file was created or used in the current compilation.
--pch_mem
size The number of 1024-byte units of preallocated
memory in which to save precompiled-header state (for
platforms where we have chosen not to use memory mapping or where
it was not reasonably available). Contact us if you feel that
you need to use this option.
--restrict
--no_restrict Enable
or disable recognition of the restrict keyword.
--long_lifetime_temps
--short_lifetime_temps
Select the lifetime for temporaries: "short" means
to end of full expression; "long" means to the earliest
of end of scope, end of switch clause, or the next label. "short"
is standard C++, and "long" is what cfront uses (the
cfront compatibility modes select "long" by default).
--microsoft
--microsoft_16
--no_microsoft Enable or disable recognition
of Microsoft extensions, as appropriate and applicable. --microsoft
enables 32-bit mode. --microsoft_16 enables 16-bit mode
(though only a few Microsoft 16-bit extensions are supported).
When
Microsoft extensions are recognized, language features that are
not recognized by the Microsoft compiler are disabled by default.
In most cases these features can then be enabled through use
of other command line options (for example, --bool).
Note that these options are only recognized under MS-Windows, or if you have a custom port of Comeau C/C++.
--far_data_pointers
--near_data_pointers
--far_code_pointers
--near_code_pointers Set the default
size for pointers in 16-bit Microsoft mode, i.e., the memory model.
Ignored in other modes.
--wchar_t_keyword
--no_wchar_t_keyword
Enable or disable recognition of wchar_t as a keyword.
This
option is valid only in C++ mode. The front end can be configured
to define a preprocessing variable when wchar_t is recognized
as a keyword. This preprocessing variable may then be used by
the standard header files to determine whether a typedef should
be supplied to define wchar_t.
--bool
--no_bool
Enable or disable recognition of bool. This
option is valid only in C++ mode. The front end can be configured
to define a preprocessing variable when bool is recognized.
This preprocessing variable may then be used by header files to
determine whether a typedef should be supplied to define bool.
--typename
--no_typename Enable or disable recognition of typename.
This
option is valid only in C++ mode.
--implicit_typename
--no_implicit_typename
Enable or disable implicit determination, from context, whether
a template parameter dependent name is a type or nontype. The
default value is implicit
inclusion and can be changed via a custom porting arrangement.
This option is valid only in C++ mode.
--special_subscript_cost
--no_special_subscript_cost
Enable or disable a special nonstandard weighting of the conversion
to the integral operand of the [] operator in overload
resolution. This is a compatibility feature that may be useful
with some existing code. The special cost is enabled by default
in cfront 3.0 mode. With this feature enabled, the following code
compiles without error:
struct A {
A();
operator int *();
int operator[](unsigned);
};
int main() {
A a;
a[0];//Ambiguous,but allowed with this
//option, operator[] is chosen
return 0;
}
--alternative_tokens
--no_alternative_tokens
Enable
or disable recognition of alternative tokens. This controls recognition
of the digraph tokens in C and C++, and controls recognition of
the operator keywords (e.g., and, bitand, etc.)
in C++.
--inlining
--no_inlining
Enable or disable minimal inlining of function calls. The
default is to do inlining when the C-generating back end is used.
--remove_unneeded_entities
--no_remove_unneeded_entities
Enable or disable an optimization to prune the IL tree of types,
variables, routines, and related IL entries that are not "really
needed." (Something may be referenced but unneeded if is
referenced only by something that is itself unneeded; certain
entities, such as global variables and routines defined in the
translation unit, are always considered to be needed.)
--pack_alignment=n
Set the default alignment for packing classes and structs
to n, a power-of-2 value.
The argument n is the default maximum alignment for nonstatic
data members; it can be overridden by a #pragma pack
directive.
--svr4
--no_svr4
Enable or disable recognition of SVR4 C compatibility features.
This
option also specifies that the source language being compiled
is ANSI C.
--brief_diagnostics
--no_brief_diagnostics
Enable or disable a mode in which a shorter form of the diagnostic
output is used. When enabled, the original source line is not
displayed and the error message text is not wrapped when too long
to fit on a single line.
--wrap_diagnostics
--no_wrap_diagnostics
Enable or disable a mode in which the error message text
is not wrapped when too long to fit on a single line.
--nonconst_ref_anachronism
--no_nonconst_ref_anachronism
Enable or disable the anachronism of allowing a reference to nonconst
to bind to a class rvalue of the right type. This anachronism
is also enabled by the --anachronisms option and the
cfront-compatibility options.
--no_preproc_only May
be used in conjunction with the options that normally cause the
front end to do preprocessing only (e.g., --preprocess,
etc.) to specify that a full compilation should be done (not just
preprocessing). When used with the implicit inclusion option,
this makes it possible to generate a preprocessed output file
that includes any implicitly included files.
--old_style_preprocessing
Forces pcc style preprocessing when compiling in ANSI C or C++
mode. This may be used when compiling an ANSI C or C++ program
on a system in which the system header files require pcc style
preprocessing.
--one_instantiation_per_object
When the --one_instantiation_per_object template instantiation mode is specified, each compilation produces several object files: a primary object file plus a separate object file for each template instantiation. Therefore, --one_instantiation_per_object puts out each template instantiation in a given compilation (function or static data member) in a separate object file. In particular, the primary object file contains everything else in the compilation, i.e., everything that isn't an instantiation.
In the normal course of affairs, it may be that a large number of instantiations are assigned to one source file, therefore creating one monolithic object file containing its instantiations. Hence referring to a single instantiation in that respective file may drag in all the rest of its instantiations as well. Having each instantiation in a separate object file is very useful when creating libraries, because it allows the user of the library the control to pull in only the instantiations that are needed. That can be important if two different libraries include some of the same instantiations. The resulting separate object files are placed in a directory specified by the --instantiation_dir=<name> command-line option. The default instantiation directory is named Template.dir. This option is valid only in C++ mode, and only on platforms it has been made available for.
--instantiation_dir=dir-name
This option can be used to specify a directory into which the generated object files from the use of --one_instantiation_per_object option should be put. The default directory name used is Template.dir if this option is not specified by the user. As with the --one_instantiation_per_object option, this option is valid only in C++ mode, and only on platforms it has been made available for.
(c)© 1997-2013 Comeau Computing, EDG. All rights reserved.
Comeau Computing
91-34 120th Street
Richmond Hill, NY 11418-3214
Back to documentation Table of Contents
http://www.comeaucomputing.com
/* the end */