Build C++ Builder Action

Project

Project File

The CBuilder project or package file to be compiled. Reloading the project/package file will read all the settings contained within it and overwrite those set in the actions dialog. 

Icon

The icon to include as the generated executables icon. 

Options

Build All

Specify to have all the source built for the listed project. 

Regenerate Resource File

Specify to have any resource files attached to the project regenerated. 

Build with Runtime Packages

Specify the runtime packages for the project to use. Each package is separated with semi-colon and only requires the files name. 

Make Options

Use command line options to control the behaviour of make. Each option is case sensitive, should be preceded with a slash or hyphen. Each options is separated with a space. 

Capture Make Output

Whether to write output from make to the build log or not. By default is is turned on. Note that not including this output means make getting to the bottom of why a build failed will be harder. 

BPR2Make Options

Use command line options to control the behaviour of BPR2Make (C++ Builder 6 and earlier compiler). Each option is case sensitive, should be preceded with a slash or hyphen. Each options is separated with a space. 

Use Package Options

Select to use the package options set in the action. 

Use Directory Options

Select to use the directory options set in the action.

Use Compiler Options

Select to use the compiler options set in the action.

Use Adv Compiler Options

Select to use the advanced compiler options set in the action.

Use Linker Options

Select to use the linker options set in the action.

Use Adv LInker Options

Select to use the advanced linker options set in the action.

Use TLib Options

Select to use the TLib options set in the action.

Use EurekaLog Compiler

Select to use the eurekalog options set in the action.

Use Version Info Options

Select to use the version information options set in the action.

Use C++ Options

Select to use the C++ options set in the action.

Use Pascal Options

Select to use the pascal options set in the action.

Use TASM Options

Select to use the TASM options set in the action.

Use Corba Options

Select to use the Corba options set in the action.

Use CodeGuard Options

Select to use the CodeGuard options set in the action.

Pre-process Project File

Select to have the project file pre-processed to gather options it has set. 

Compiler

Code Optimisations

None

Disables all optimisations. As this also removes cross-jumping and other compiler tricks it can make stepping through source code while debugging easier. 

Speed

Tells the compiler to optimise for speed.

Selected

Allows for the selection of specific optimisations. This is typically chosen when a particular optimisation included in the speed optimisation set causes issues with the produced executable. 

Warnings

None

Disable any warnings from being generated during the compile. 

All

Include all warnings generated from the compiler. 

Selected

Include only a selected list of warnings which are checked for by the compiler. Typically this is the option chosen as some warnings are too strict for them to be of meaningful use. 

Pre-compiler headers

None

Signal that the compiler is not to use pre-compiled headers. 

Use pre-compiled headers

Signal that the compiler should use a pre-compiled header file. This is the default, and the IDE typically creates a pre-compiled header file for the project. 

Cache pre-compiled headers

Signal that the compiler should cache the pre-compiled header files that it generates or uses. 

Filename

The name of the pre-compiler header file. 

Stop after

Terminates compiling the pre-compiled header file after the named file is compiled. 

Debugging

Debug Information

Signal that debug information should be included in the generated object files. This option is then passed onto the linker so that it can include debugging information as well. 

Line number information

Signal that the object file, and object map files should contain line number information for debugging purposes. 

Disable inline expansion

Signals that inline expansion of functions and methods should not occur. This stops inline code from being generated which can make debugging easier. This produces slower performing code. 

Compiling

Merge duplicate strings

Merges two literal strings when one matches another.

Stack frames

When checked the compiler will include the standard stack frame for every method call. When off functions which don't have local variables or parameters will be compiled in an abbreviated way without a stack frame. 

Treat enum types as ints

Instructs the compiler to allocate the size of an entire integer to enumerations used throughout the source code. 

Extended error information

The compiler will include "extended" information when errors occur. 

Advanced Compiler

Instruction Set

08386

Generates 80386 protected-mode compatible instructions

i486

Generates i486 protected-mode compatible instructions.

Pentium

Generates Pentium instructions.

Pentium Pro

Generates Pentium Pro instructions.

Data Alignment

Byte

Does not force any alignment of variables. Alignment occurs at the next available address. This produces compact programs, but they typically run slower than other alignment methods. 

Word

Two byte alignment for variables. 

Double word

Four byte alignment for variables. Anything over four bytes are aligned on their type size. 

Quad word

Eight byte alignment for variables. Anything over eight bytes are aligned on their type size. 

Calling Convention

C

Instructs the compiler to use the __cdecl calling sequence for method calls. Can be overridden with local uses of __pascal, __fastcall, and __stdcall.

Pascal

Instructs the compiler to use the __pascal calling sequence for method calls. Can be overridden with local uses of __cdecl, __fastcall, and __stdcall. 

Register

Instructs the compiler to use the __fastcal calling sequence for method calls. Can be overridden with local uses of __pascal, __cdecl, and __stdcall.

Standard call

Instructs the compiler to use the __stdcall calling sequence for method calls. Can be overridden with local uses of __pascal, __fastcall, and __cdecl.

Register Variables

None

Disables the use of register variables. 

Automatic

Automatically assign register variables if possible. 

Register keyword

Only allow the use of registry variables only if they specify the register keyword. 

Output

Autodependency information

Includes the results of autodependency checking into object files. When disabled, source files that have changed includes are not rebuilt. 

Generate underscores

When specified the compiler will add an underscore to all global functions and variables before they are updated into their object files. 

Floating Point

None

Uses the quiet floating point instruction. 

Fast

Floating-point operations will be optimized ignoring type conversions. These optimization do not follow the strict ANSI rules regarding floating-point conversions, yet produce faster code. 

Correct Pentium FDIV flaw

Some early Pentium chips do not perform floating-point division with full precision. This option will replace floating-point division code with code which will work on all processors. As a result all floating-point divisions in the code will execute slower. 

Language Compliance

Borland

Allow the usage of Borland keywords and extensions. 

ANSI

Use the ANSI keywords and extensions. The most portable compilation language. 

Unix V

Use the Unix V keywords and extensions. It also treats the Borland keywords and extensions as normal identifiers. 

K & R

Use the Kernighan and Ritchie keywords and extensions. 

Source

Nested comments

Whether nested comments should be allowed by the compiler or not. Typically nested comments are not allowed in the C standard, therefore turning this option on will most likely mean the code is not portable to other compilers. 

MFC Compatibility

The compiler is instructed that is should produce MFC compatible code. 

Identifier length

The number of characters in an identifier that are treated as significant. Note that C++ allows for an unlimited length, however this compiler has a limit up to 250. 

Linker

Linking

Create debug information 

Debug information is included into the output files used by the C++ debugger. 

Use dynamic RTL

Specify if the C CTL should be linked dynamically with the run-time library. 

Generate import library

An import library file will be generated. The file is a static library which contains information on exports which can be linked against. 

Generate .lib file

A static import library is generated. 

Don't generate state files

Stops the use of linker state files. These linker state files cache previous activities performed by the linker, speeding up the process. Stopping this means that each linking operation will take just as long as the previous, and will be done in isolation.

Max errors

The maximum number of errors before the linker will stop.

Map file

Linker can generate a map file which contains general segment information about the generated code.

Off

No map file is produced.  

Segments

Generates a map file which includes general segments such as start address. Also includes hints and warnings messages produced during linking.

Publics

Generates the same information as the segments level with the addition of information about public symbols.

Details

Generates the same information as the publics level with the addition of a resource string file. Added to this the detailed segment map includes the segment address, length in bytes, segment name, group, and module information.

Show managed names

Includes the names of classes and functions into a public section of the map file. 

Warnings

All

Include all linker warnings. 

Selected

Include only the selected linker warnings. 

PE file options

Min stack size

Sets the memory committed for the stack. Can be a hexadecimal or decimal value. Minimum value is 4k (0x1000).

Max stack size

Sets the memory reserved for the stack. Can be a hexadecimal or decimal value. Minimum value is 4k (0x1000).

Min heap size

Sets the memory committed for the heap.

Max heap size

Sets the memory reserved for the heap. 

Image base

The base address of the executable or DLL.

Subsystem major

The Windows subsystem major version number required to run the image. 

Subsystem minor

The Windows subsystem minor version number required to run the image. 

Advanced Linker

Advanced

Case-insensitive link

The linker differentiates between upper and lowercase characters in public and external symbols. Normally, this option should be set, since C and C++ are both case-sensitive languages.

Calculate checksum

Calculates the checksum of the target and places the result in the target's PE header. 

Replace resources

Add and/or replace resources without stripping away the existing resources.

User version

User major version

The major version number for the user versions binary information. 

User minor version

The minor version number for the user versions binary information.

Image

Image Comment

Specifies comments to be inserted into the image directly after the object table in the PE file header.

Delay Load

DLLs to delay load

Specifies DLLs that are to be delay loaded.

C++

Member pointers

All Cases

No options set for member pointers. 

Multiple Inheritance 

Member pointers can point to members of multiple inheritance classes.

Single Inheritance 

Member pointers can point only to members of base classes that use single inheritance.

Smallest

Member pointers use the smallest possible representation that allows them to point to all members of their particular class. 

Honour member precision

The compiler uses the declared precision for member pointer types.

Compatibility

Don't restrict for loop scope

Check this to not limit loops to their own scope. 

Don't mangle code modifiers

Check this to not manage modifiers. 

General

Zero length empty base classes

Usually the size of a class is at least one byte, even if the class does not define any data members. 

Zero length empty class members

Usually the size of a data member in a class definition is at least one byte. When this option is enabled, the compiler allows an empty structure of zero length.

Templates 

External

Generate external references for all template instances.

Exception Handling

Enable RTTI

The compiler is instructed to generate code that allows run-time type identification information. If Destructor Cleanup is set, this typically needs to be set as well. 

Enable Exceptions

The compiler is instructed to compile exception handling code in the application. 

Location Information

When this is enabled run-time type information is available for exceptions. The compiler provides filename and source code line numbers for where exceptions occur. 

Destructor cleanup 

When exceptions are thrown, destructor's will be called automatically for all objects in the scope between the catch and throw.  

Fast exception prologs

Expands inline code for every exception handling function. This results in improved performance. 

Virtual Tables

Smart 

Generates common C++ virtual tables and out-of-line inline functions across the modules in your application. This the default and generates the smallest and most efficient executables. 

External

Generates external references to virtual tables. 

Public 

Generates public definitions for virtual tables. When using External option at least one of the modules needs to be compiled with Public options to provide definitions for the virtual tables. 

Compile mode

Force C++ compile

Force the compiler to use C++ mode. 

Pascal Options

Code Generation

Optimizations

When turned on the Delphi compiler will perform code optimisations. Examples of these are (but not limited to):

• Placing variables in CPU registers
• Eliminating common subexpressions
• Generating induction variables

All optimization operations are considered "safe" and don't alter the meaning of the program. 

Stack frames

When turned on stack frames are created for every procedure and function in the source code for the project. When turned off stack frames are only generated when they are required. 

Pentium-safe FDIV

When turned on the compiler will generate floating point code which will protect again the FDIV flaw in Pentium processors. Some operating systems correct this issue system wide and therefore don't require this fix (Win95, WinNT, and higher).

Record field alignment

Determines the maximum padding that can be used to align a field. Each setting has some extra side affects these are listed below;

• 1: Fields are not aligned, all structures are packed. 
• 2: Fields in non-packed records and in class structures are aligned on word boundaries.
• 4: Fields in non-packed records and in class structures are aligned on doubleword boundaries.
• 8: Fields in non-packed records and in class structures are aligned on quadword boundaries.

Variables and typed constants are all aligned with optimal access in mind. 

Syntax options

Strict var-strings

When turned on the compiler will enforce type checking for short strings passed as variable parameters. This is really only important for Delphi code which uses short strings. 

Complete boolean eval

When turned on the compiler generates code in which all components of an AND and OR statement are evaluated. Therefore guarenteeing calling of each component on the statement.

When off the compiler generates code which short circuits the statements. This means when evaluated in left to right order, if the result of the statement has become apparent no more of the statement is called. 

Extended syntax

Determines whether Delphi Extended Syntax should be used or not. When enabled the following Delphi features are able to be used;

• Function Statements
• The Result Variable
• Strings Compatible with PChar

Typed @ operator

Determines how the compiler should treat the @ operator and compatibility of pointer types. 

• Enabled: Only pointers of the same type are compatible. All @ operations create a variable which has pointer type specific to the variable the @ was applied to. 
• Disabled: All @ operators generate an un-typed pointer. This pointer is compatible with all other pointer types.  

Open parameters

Controls the compilers interpretation of variable parameter strings. When disabled variable string parameters are not treated differently. When enabled variable string parameters are treated as open strings. Regardless of this setting OpenString identifier can be used at any-time. 

Huge strings

Determines how the compiler interprets string types. When On this options will mean the compiler will use AnsiString, when off the compiler will use ShortString.  

Assignable type contants

Controls as to whether the compiler will allow typed contants to be altered or not. When turned On constants are able to be assigned to. When Off constants are not able to be assigned to. In some older code this option is required for the code to compile, for newer projects its suggested to not enable this option. 

Runtime errors

Range checking

When enabled all array and string indices are validated to be within the bounds of the variable. In addition all scalar and subrange variables are validated to within their bounds. Having this option enabled adds extra checking to the generated code, and therefore will execute slower. 

I/O checking

When enabled all I/O procedures have code generated which checks for non-zero return results. When a non-zero return result is detected an EInOutError exception is raised. 

Overflow checking

When enabled the arithmetic operations of +, -, *, Abs, Sqr, Succ, Pred, Inc, and Dec are have results checked for overflowing the returned variables type. Having this option enabled adds extra checking to the generated code, and therefore will execute slower. 

Debugging

Debug Information

When enabled the compiler is signalled to generate debugging information which is maps object-code to address into the source text file. This information is stored in the unit file with unit object code. This does not affect the speed of generated code, however does cause the compilation process to take up more memory.

Local symbols

When enabled the compiler generates local symbol information. Local symbol information is the name and type of all local variables and constants in the a module. This information is stored in the unit file with unit object code. This does not affect the speed of generated code, however does cause the compilation process to take up more memory.

Reference info

When enabled the compiler generates symbol reference information. This information is typically used by the Code Editor and the Project manager. Some other tools may require it. 

Definitions only

In combination with the Reference Info option, this option simply limits the reference information generated to just when identifiers are defined. If turned off, information would be generated for when identifiers are defined and when they are referenced. 

Assertions

Determines whether the compiler should include assert generation or not. When turned On assert calls will be included into the generated code. When turned Off assert calls will be omitted from the generated code. 

Messages

Show hints

Whether to report hints into the build log or not. 

Show warnings

Whether to report warnings into the build log or not. 

TASM Options

Debug Information 

None

Disables debug information in the object file.

Line numbers

Tells the Turbo Assembler to include line-number records to synchronize source code display and data type information. This is the default.

Full

Lets you use all the features of the debugger to step through your program and examine or change data items.

Case sensitivity

None

Disables all case-sensitivity checks. 

Globals

Case-sensitivity checks are only performed on external and public symbols. 

All

Turns case-sensitivity checks on for every symbol.

Warnings

None

Disables all warnings. 

Level 1

Generates all warnings. 

Level 2

Generates only selected warnings. 

Selections

Hash table capacity

Sets the maximum number of symbols an assembler file can use.

Maximum passes

Sets the maximum number of assembly passes. 

Maximum symbol length

Sets the maximum length of symbols that Tasm can distinguish between. The minimum number allowed is 12. The default is 12.

Add directive

Enter any additional switches that you want to use with the Turbo Assembler.

Generate listings

Listing type

Normal listing: Generates listing and places it in a file with the .LST extension.

Expanded listing: Shows all generated code in the listing file. The default is False.

Cross reference

Adds cross-reference information to the symbol table at the end of the listing file.

Symbol tables information

Includes the generation of symbol table information in the listing file.

Include false conditionals

Lists the conditional directives that evaluate to False.

Include error messages

List errors occurring from the Tubro Assembler run.

Directories

Directory options

Include path

Specifies the drive and/or directories that contain program include files. 

Library path

Specifies the drive and/or directories that contain program library files. 

Intermediate output

Location where temporary files used during compiling and linking are placed. 

Final output

Location where the final result of the compile and linking will be written to. 

Use BCB environment settings for final output

Check this to use the environment settings for the final output directory.

BPI/LIB output

The final output location for lib and bpl files. 

Use BCB environment settings for BPI/LIB output path

Check this to use the environment settings for the lib output path. 

Conditional defines

Defines a list of macros.

Version Info

Include version information in project

Whether the linker should include version information into the generated binary or not. 

Use Property Set for Version Info

Whether to use a Property Set for the version information of the generated binary or not. 

Module version number

Major version 

The major version number of the generated binary. Can be set directly, or taken from a supplied Property Set.

Minor version

The minor version number of the generated binary. Can be set directly, or taken from a supplied Property Set.

Release 

The release version number of the generated binary. Can be set directly, or taken from a supplied Property Set.

Build

The build version number of the generated binary. Can be set directly, or taken from a supplied Property Set.

Auto-increment build number

Whether to automatically increase the build number portion of the Module Version Number or not. If the number is increased the value is updated into the action. The project will need to be saved so that this persists for the next execution. 

Module Attributes

A binary can be marked with a number of different attributes. These are namely

Debug build

Indicates that the project was compiled in debug mode.

 Special build

Indicates that the version is a variation of the standard release.

DLL

Indicates that the project includes a dynamic-link library.

Pre-release

Indicates the version is not the commercially released product.

Private build

Indicates that the version was not built using standard release procedures

Language

The primary language of the binary. 

Code Page

Determines the default text character set that is used in ANSI source code. This is used by the compiler in working out how to parse multibyte character strings. This typically includes;

• String constants
• Comments
• #error directive
• #define directive

Locale ID

The locale ID which relates to the code page selected. 

Version Information

All the version information which will be attached to the binary when its generated. These can either be sourced from the Project Settings, Property Set, or set directly in the dialog. 

Include Compile Date in Version Info

Where to update the version information to have the date of the action run included into the version information as the compile date. 

Auto-Update FileVersion String

Whether to automatically update the FileVersion string based on the FileVersion major, minor, release, and build numbers. 

Link ProductVersion to FileVersion

Whether to link the ProductVersion file in the version information to the FileVersion field. Typically used if the product has only one version number across all parts of the build. 

Auto-Update ProductVersion String

Whether to automatically update the ProductVersion string based on the ProductVersion major, minor, release, and build numbers.

CodeGuard Validation

CodeGuard Validation

Validate global and stack accesses

Creates data and stack layout descriptors for fast lookup by CodeGuard.

Validate the 'this' pointer on member function entry

Creates special epilogues for member functions, constructors, and destructor's. CodeGuard verifies the this pointer on entry to every method in C++ code.

Validate pointer access

This CodeGuard option generates calls to verify all accesses in your code.

CORBA

Code generation

Object wrappers

Generate type object wrapper code. 

Tie

Suppress generate of tie code. 

Virtual imp. inheritance

Generate virtual interface implementation inheritance.

Typecode information

Generate type code information.

Include files code

Generate code for included files.

Stream operators

Suppress generation of class stream operators.

File extensions 

Header extension

Specify header file suffix. 

Source extension

Specify source file suffix.

Additional IDL

Options

Specify any additional IDL options here. 

IDL Compilation

Add server unit to project

Whether the project should have a server unit added to it or not. 

Add client unit to project

Whether the project should have a client unit added to it or not. 

Precompiled header support

Specifies if COBRA projects should support pre-compiled header files or not. 

Corba.h options

Include IR

Includes the interface repository header file into the CORBA header file. 

Include DSI

Includes the dynamic skeleton interface file into the CORBA header file.