This action also allows you to generate Version Info for the project, and auto increment build numbers.
The way the action works is this :
This action provides support for Embarcadero's C++ Builder versions 5 and 6. The action allows you to selectively override the settings in the project file with the settings in FinalBuilder. It provides the same interface as the Project Options dialog in BCB.
There are some known problems with this action.
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.
The icon to include as the generated executables icon.
Specify to have all the source built for the listed project.
Specify to have any resource files attached to the project regenerated.
Specify the runtime packages for the project to use. Each package is separated with semi-colon and only requires the files name.
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.
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.
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.
Select to use the package options set in the action.
Select to use the directory options set in the action.
Select to use the compiler options set in the action.
Select to use the advanced compiler options set in the action.
Select to use the linker options set in the action.
Select to use the advanced linker options set in the action.
Select to use the TLib options set in the action.
Select to use the eurekalog options set in the action.
Select to use the version information options set in the action.
Select to use the C++ options set in the action.
Select to use the pascal options set in the action.
Select to use the TASM options set in the action.
Select to use the Corba options set in the action.
Select to use the CodeGuard options set in the action.
Select to have the project file pre-processed to gather options it has set.
Disables all optimisations. As this also removes cross-jumping and other compiler tricks it can make stepping through source code while debugging easier.
Tells the compiler to optimise for speed.
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.
Disable any warnings from being generated during the compile.
Include all warnings generated from the compiler.
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.
Signal that the compiler is not to 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.
Signal that the compiler should cache the pre-compiled header files that it generates or uses.
The name of the pre-compiler header file.
Terminates compiling the pre-compiled header file after the named file is compiled.
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.
Signal that the object file, and object map files should contain line number information for debugging purposes.
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.
Merges two literal strings when one matches another.
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.
Instructs the compiler to allocate the size of an entire integer to enumerations used throughout the source code.
The compiler will include "extended" information when errors occur.
Generates 80386 protected-mode compatible instructions
Generates i486 protected-mode compatible instructions.
Generates Pentium instructions.
Generates Pentium Pro instructions.
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.
Two byte alignment for variables.
Four byte alignment for variables. Anything over four bytes are aligned on their type size.
Eight byte alignment for variables. Anything over eight bytes are aligned on their type size.
Instructs the compiler to use the __cdecl calling sequence for method calls. Can be overridden with local uses of __pascal, __fastcall, and __stdcall.
Instructs the compiler to use the __pascal calling sequence for method calls. Can be overridden with local uses of __cdecl, __fastcall, and __stdcall.
Instructs the compiler to use the __fastcal calling sequence for method calls. Can be overridden with local uses of __pascal, __cdecl, and __stdcall.
Instructs the compiler to use the __stdcall calling sequence for method calls. Can be overridden with local uses of __pascal, __fastcall, and __cdecl.
Disables the use of register variables.
Automatically assign register variables if possible.
Only allow the use of registry variables only if they specify the register keyword.
Includes the results of autodependency checking into object files. When disabled, source files that have changed includes are not rebuilt.
When specified the compiler will add an underscore to all global functions and variables before they are updated into their object files.
Uses the quiet floating point instruction.
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.
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.
Allow the usage of Borland keywords and extensions.
Use the ANSI keywords and extensions. The most portable compilation language.
Use the Unix V keywords and extensions. It also treats the Borland keywords and extensions as normal identifiers.
Use the Kernighan and Ritchie keywords and extensions.
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.
The compiler is instructed that is should produce MFC compatible code.
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.
Debug information is included into the output files used by the C++ debugger.
Specify if the C CTL should be linked dynamically with the run-time library.
An import library file will be generated. The file is a static library which contains information on exports which can be linked against.
A static import library is generated.
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.
The maximum number of errors before the linker will stop.
Linker can generate a map file which contains general segment information about the generated code.
No map file is produced.
Generates a map file which includes general segments such as start address. Also includes hints and warnings messages produced during linking.
Generates the same information as the segments level with the addition of information about public symbols.
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.
Includes the names of classes and functions into a public section of the map file.
Include all linker warnings.
Include only the selected linker warnings.
Sets the memory committed for the stack. Can be a hexadecimal or decimal value. Minimum value is 4k (0x1000).
Sets the memory reserved for the stack. Can be a hexadecimal or decimal value. Minimum value is 4k (0x1000).
Sets the memory committed for the heap.
Sets the memory reserved for the heap.
The base address of the executable or DLL.
The Windows subsystem major version number required to run the image.
The Windows subsystem minor version number required to run the image.
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.
Calculates the checksum of the target and places the result in the target's PE header.
Add and/or replace resources without stripping away the existing resources.
The major version number for the user versions binary information.
The minor version number for the user versions binary information.
Specifies comments to be inserted into the image directly after the object table in the PE file header.
Specifies DLLs that are to be delay loaded.
No options set for member pointers.
Member pointers can point to members of multiple inheritance classes.
Member pointers can point only to members of base classes that use single inheritance.
Member pointers use the smallest possible representation that allows them to point to all members of their particular class.
The compiler uses the declared precision for member pointer types.
Check this to not limit loops to their own scope.
Check this to not manage modifiers.
Usually the size of a class is at least one byte, even if the class does not define any data 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.
Generate external references for all template instances.
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.
The compiler is instructed to compile exception handling code in the application.
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.
When exceptions are thrown, destructor's will be called automatically for all objects in the scope between the catch and throw.
Expands inline code for every exception handling function. This results in improved performance.
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.
Generates external references to virtual tables.
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.
Force the compiler to use C++ mode.
When turned on the Delphi compiler will perform code optimisations. Examples of these are (but not limited to):
All optimization operations are considered "safe" and don't alter the meaning of the program.
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.
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).
Determines the maximum padding that can be used to align a field. Each setting has some extra side affects these are listed below;
Variables and typed constants are all aligned with optimal access in mind.
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.
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.
Determines whether Delphi Extended Syntax should be used or not. When enabled the following Delphi features are able to be used;
Determines how the compiler should treat the @ operator and compatibility of pointer types.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Whether to report hints into the build log or not.
Whether to report warnings into the build log or not.
Disables debug information in the object file.
Tells the Turbo Assembler to include line-number records to synchronize source code display and data type information. This is the default.
Lets you use all the features of the debugger to step through your program and examine or change data items.
Disables all case-sensitivity checks.
Case-sensitivity checks are only performed on external and public symbols.
Turns case-sensitivity checks on for every symbol.
Disables all warnings.
Generates all warnings.
Generates only selected warnings.
Sets the maximum number of symbols an assembler file can use.
Sets the maximum number of assembly passes.
Sets the maximum length of symbols that Tasm can distinguish between. The minimum number allowed is 12. The default is 12.
Enter any additional switches that you want to use with the Turbo Assembler.
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.
Includes the generation of symbol table information in the listing file.
Lists the conditional directives that evaluate to False.
List errors occurring from the Tubro Assembler run.
Specifies the drive and/or directories that contain program include files.
Specifies the drive and/or directories that contain program library files.
Location where temporary files used during compiling and linking are placed.
Location where the final result of the compile and linking will be written to.
Check this to use the environment settings for the final output directory.
The final output location for lib and bpl files.
Check this to use the environment settings for the lib output path.
Defines a list of macros.
Whether the linker should include version information into the generated binary or not.
Whether to use a Property Set for the version information of the generated binary or not.
The major version number of the generated binary. Can be set directly, or taken from a supplied Property Set.
The minor version number of the generated binary. Can be set directly, or taken from a supplied Property Set.
The release version number of the generated binary. Can be set directly, or taken from a supplied Property Set.
The build version number of the generated binary. Can be set directly, or taken from a supplied Property Set.
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.
A binary can be marked with a number of different attributes. These are namely
Indicates that the project was compiled in debug mode.
Indicates that the version is a variation of the standard release.
Indicates that the project includes a dynamic-link library.
Indicates the version is not the commercially released product.
Indicates that the version was not built using standard release procedures
The primary language of the binary.
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;
The locale ID which relates to the code page selected.
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.
Where to update the version information to have the date of the action run included into the version information as the compile date.
Whether to automatically update the FileVersion string based on the FileVersion major, minor, release, and build numbers.
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.
Whether to automatically update the ProductVersion string based on the ProductVersion major, minor, release, and build numbers.
Creates data and stack layout descriptors for fast lookup by CodeGuard.
Creates special epilogues for member functions, constructors, and destructor's. CodeGuard verifies the this pointer on entry to every method in C++ code.
This CodeGuard option generates calls to verify all accesses in your code.
Generate type object wrapper code.
Suppress generate of tie code.
Generate virtual interface implementation inheritance.
Generate type code information.
Generate code for included files.
Suppress generation of class stream operators.
Specify header file suffix.
Specify source file suffix.
Specify any additional IDL options here.
Whether the project should have a server unit added to it or not.
Whether the project should have a client unit added to it or not.
Specifies if COBRA projects should support pre-compiled header files or not.
Includes the interface repository header file into the CORBA header file.
Includes the dynamic skeleton interface file into the CORBA header file.