Comeau C/C++ 4.x
User-Documentation

  1. 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:

  1. The directory containing the current input file (the primary source file or the file containing the #include);
  2. Any directories specified in --include_directory options (in the order in which they were listed on the command line);
  3. 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 */