16. More about Project Build Settings
This chapter details the options for controlling how a project is built continuing from Chapter 15, More about Projects and Workspaces. It lists and explains the options on the Build page of the Project Settings dialog box. Access these options by selecting Settings from the Project menu, then clicking on the Build tab.The Build page of the Project Settings dialog box is composed of 18 subpages. The subpages are displayed in a listbox on the left of the window. To access a particular subpage, click on its name. The options displayed on the right change with each subpage. Subpages are organized hierarchically, as shown in the listbox.
This chapter covers all the subpages on the Build page of the Project Options dialog box. The first section introduces the build settings and the Project Settings dialog box, and the later sections describe the subpages in the order in which they are listed on the Build page.
For more detailed information on how each of these options affects the compilation of code, refer to the Compiler and Tools Guide. Appendix B, IDDE Settings and Command-Line Options, details how each of these options map to the corresponding DMC, Optlink, Make, or Librarian command line options.
Introducing Build Settings
Choose the Settings command from the IDDE's Project menu to open the Project Settings multipage dialog box. Using the tabs at the top of the dialog box, select different pages, each of which presents a set of options.Click on the Build tab in the dialog box to open the Build page. The Build page is composed of subpages of options. Select a subpage by clicking on its name in the listbox on the left of the Build page. The following subpages are available:
- Compiler
- Code Generation
- Header Files
- Memory Models
- Code Optimizations
- Windows Prolog/Epilog
- Output
- Warnings
- Debug Information
- Linker
- Packing & Map File
- Definitions
- Segments
- Imports/Exports
- Resource Compiler
- Make
- External Make
- Librarian
Compiler
The Compiler subpage (Figure 16-1) contains a variety of parameters controlling compilation.
[Figure 16-1 Compiler subpage]
Enforce ANSI compatibility
Establishes the necessary parameters so the compiler accepts only C/C++ code that conforms to ANSI standards. Refer to the Compiler and Tools Guide for information on the restrictions that take effect.Treat source as C++
With this option selected, the compiler treats C source files as C++ files. The option is useful for:- Compiling the file to take advantage of type-safe linkage
- Linking a C file to a C++ file without changing it or giving it a C++-compatible extension
Relax type checking
Causes the compiler to use relaxed (non-ANSI) type checking. The following data types are then treated as equivalent:- char == signed char == unsigned char
- short == unsigned short
- long == unsigned long
- int == unsigned == enum == short
- int == unsigned == enum == long
Suppress predefined macros
Suppresses the definition of the non-ANSI predefined macros.Exception handling
Enables implementation of exception handling.Run-time type information
Enables implementation of run-time type information.Enable new[], delete[] overloading
Enables overloading of operator new[] and operator delete[]. It also sets the predefined macro _ENABLE_ARRAYNEW to 1.Compiling with Enforce ANSI compatibility automatically enables this option.
char behavior
This option controls the way the compiler treats a char type. By default, the compiler treats char types as signed. Set this option to unsigned to quickly port code that depends on unsigned char types. Note that the behavior of the run-time library routines is not affected by this option unless they are also recompiled.- signed:
- Makes char types behave as signed char types.
- unsigned:
- Makes char types behave as unsigned char types.
- char == unsigned char:
- Changes the type of char to be unsigned.
Prototyping
This option specifies how the compiler handles function prototypes. New code should always be fully prototyped, due to the requirements of type-safe linkage and the support for alternative linkage conventions.There are three prototyping possibilities: Standard, Autoprototype, and Strict.
- Standard:
- Turns off autoprototyping and strict prototyping.
- Autoprototype:
- Enables the compiler to generate a prototype according to the way the function is used, even if one is not specified for a function. Subsequent uses are checked against the generated prototype. This is especially useful when compiling old C code that is not completely prototyped.
- Strict:
- Requires that all functions be declared (prototyped) before being used. This declaration provides the compiler with the function name, return type, and storage class of a function, as well as the number and type of arguments that may be passed to it. Once the compiler encounters a function prototype, it can check each function call in the source file against that prototype and flag an error for the calls that do not match it.
International characters
This option specifies how the compiler interprets 2-byte Asian language character codes within character constants and strings. That is, if a character code represents the first byte of a 2-byte sequence, the second byte is not checked to see whether it is a backslash or a closed quote. The second byte cannot be a NULL (0), a carriage return (0x0D), or an end-of-file (0x1A).- None:
- Allows no 2-byte sequences.
- Japanese:
- Signals the 2-byte sequence with a value in the range 0x81 ... 0x9F and 0xE0 ... 0xFC
- Taiwanese/Chinese:
- Signals the 2-byte sequence with a value in the range 0x81 ... 0xFC
- Korean:
- Signals the 2-byte sequence with a value in the range 0x81 ... 0xFD
Other options
The options below direct the compiler to define a macro, include a header file, or instantiate a template.Defines
Specify macro definitions on the compiler command line. Separate multiple Defines with a semicolon (;).Include filename
Directs the compiler to include a header file for all modules in the project.Instantiate template
Creates an instance of a template in the program.Code Generation
The Code Generation subpage, shown in Figure 16-2, contains parameters that control how the compiler generates code.
[Figure 16-2 Code Generation subpage
Pointer validation
Makes the resulting program validate each pointer as it is dereferenced; if the pointer is invalid, a run-time error occurs. This slows and slightly increases the size of the resulting code.Generate stack frame
Generates a stack frame for each function. The stack frame is generally for the use of the debugger.Check stack overflow
Inserts stack overflow checking at the beginning of each function. The resulting program aborts with an error message if it detects a stack overflow.Fast floating point
Directs the compiler to produce the fastest possible floating-point code. No compatibility checking is performed.Generate inline 8087 code
Causes the compiler to generate inline 80x87 instructions. It significantly speeds up floating-point code, reduces its size, and improves its accuracy.Generate virtual function tables in far data
Affects Compact and Large memory models only. It causes the virtual function tables to be placed in far data segments rather than in the code segment.Use Pascal calling convention
Makes Pascal, instead of cdecl, the default linkage for all functions and global data. Because all C library routines have cdecl linkage, they must be prototyped as such before being called. Therefore, include the appropriate header files. The main() function must also be declared cdecl for the linker to find it.Using Pascal as the default linkage type results in a roughly 3% code size reduction and a corresponding speed up in generated code.
Use Stdcall calling convention
Makes stdcall the default linkage for all functions and global data, instead of cdecl.Note: Under Windows 95 and Windows NT, Digital Mars's name mangling scheme now appends the string "@nn" to the names of all stdcall functions (where nn is the number of bytes in parameters to the function). Previous versions of Digital Mars C++ did not append this string to mangled names.
Enable function-level link
Directs the compiler to encapsulate functions in initialized common blocks (COMDAT records). This allows the linker to perform function-level linking, which results in a smaller executable.No default library
Prevents the compiler from embedding the default library record in the object file. This option can result in a significant decrease in program size when generating a large library.Set data threshold
Places large arrays in far data segments. The threshold size is set in the adjacent textbox.Code segment
These options govern the ways in which code segments are handled.Generate new segment for each function
Causes the compiler to start a new code segment each time it encounters a global far function. The name of the segment is the name of the function with _TEXT appended.Override default code segment name
Overrides the default code segment name. Type the new name in the Name textbox.Put switch tables in code segment
Places switch tables in the code segment rather than in the data segment. It is useful when data segment space is critical. Do not use this option when the code segment in a Small or Compact model program is close to overflowing.Put expression strings in code segment
Puts expression string literals into the code segment rather than wasting space in a group.Struct alignment
Sets the boundaries for structure alignment. The default is to align members within a structure on word boundaries for 16-bit programs. This maximizes speed on computers with a 16-bit bus (such as a PC-AT). The default in 32-bit DOS programs is to align on double-word boundaries to maximize performance.- Byte:
- Aligns structures on byte boundaries.
- Word:
- Aligns structures on word boundaries.
- Double Word:
- Aligns structures on double-word boundaries. This is the default for 32-bit DOS applications.
- Quad Word:
- Aligns structures on boundaries that are multiples of four words. This is the default for Win32 applications.
Target CPU
Generates code tailored for the instruction set of a specific CPU.- 88:
- Generates 16-bit code using the 8088 instruction set.
- 286:
- Generates 16-bit code using the 80286 instruction set. Programs compiled with this option will not run on an 8088 or 8086 processor.
- 386:
- Generates code optimized for machines with an 80386 CPU. Programs compiled with this option require an 80386, 80486, or Pentium processor.
- 486:
- Generates code optimized for machines with an 80486 CPU. Programs compiled with this option require a 32-bit DOS extender or 32-bit operating system, and an 80386, 80486, or Pentium CPU.
- Pentium:
- Generates code for the Pentium instruction set.
Header Files
The Header Files subpage (Figure 16-3) specifies compiler header file options.
[Figure 16-3 Header Files subpage
Precompile options
If using a large header file or numerous small headers, the compiler spends considerable time compiling the same source code over and over again. To reduce compile time, use precompiled header files; the compiler can load a precompiled header faster than it can a text header file. It is especially useful to precompile large header files that seldom change, such as windows.h.No headers
Disables generation and use of precompiled headers.All headers
In most cases, using precompiled headers is convenient and fast. The All Headers option automatically precompiles all header files defined in the project source files into the file scph. sym. The file scph. sym is always in the current directory or in the directory specified as the compiler output directory.Setting the All Headers option causes the compiler to generate the file scph.sym when it does not exist. If the scph.sym file does exist, the compiler assumes it is a precompiled header. The compiler will then test the header file to see whether all the headers it contains are older than the header file itself. If any are newer, or if the compiler flags have changed, a new scph.sym file is created; otherwise, the old file is loaded as a precompiled header. Setting the All Headers option also causes all files being compiled to use scph.sym as their precompiled header.
The compiler writes out the precompiled header when the first line in the top-level source file is encountered, and when that line is not a comment or an #include statement. To avoid problems with precompiled headers:
- Do not write any declarations that cross boundaries of header files. Each header file should be self-contained.
- Do not write any extern "C" constructs that start in one file and end in another.
- Do not depend on header files being included more than once.
- Do not write any code or data definitions in header files, only declarations.
There are two circumstances in which using precompiled headers is not recommended:
- The file being compiled causes scph.sym to be regenerated, but that file contains a subset of the header files that other files also contain.
- Included files are wrapped in #if blocks or extern "C" blocks. (The extern "C" statement is a non-include statement, so the precompiled header is written out prior to the extern "C" block.) Embed the extern "C" blocks in the included files themselves.
Specific header
Selects a header file to precompile individually. Type the header file name into the textbox.Use precompiled headers from directory
Tells the compiler to use precompiled headers from a specific directory. In the textbox, type the name of the directory in which the precompiled headers reside. If this directory is empty, no additional directories, other than the current or path directories, are searched.Include headers once
Tells the compiler to include each header file only once, even if it is named in more than one source file. Otherwise, header files are included whenever they are named in a source file. This option can be used with or without precompiled headers.Memory Models
The Memory Models subpage (Figure 16-4) specifies the memory model to be used.
[Figure 16-4 Memory Models subpage
Memory model
Controls the memory model the compiler uses by specifying its size:- Tiny:
- Tells the compiler to create a .com file active only for DOS compilations.
- Small:
- Generates code with near pointers for the code segment and the data segment.
- Medium:
- Generates code with far pointers for the code segment and near pointers for the data segment.
- Compact:
- Generates code with near pointers for the code segment and far pointers for the data segment.
- Large:
- Generates code with far pointers for both the code and data segments.
- Flat:
- Generates code for a Win32 compilation; that is active only for Win32s and DOSX compilations.
Data segment
These options control the way the compiler treats the data segment register.Assume SS==DS
Causes the compiler to generate code that assumes SS equals DS.Always reload DS
Causes the compiler to generate code that reloads DS at the beginning of each function call.Code Optimizations
Options on the Code Optimizations subpage (Figure 16-5) control how the compiler optimizes code.
[Figure 16-5 Code Optimizations subpage
Optimization for
These radio buttons control the type of optimization. Optimize for speed or space, select a custom set of optimizations, or disable optimization.- Speed:
- Optimizes code for speed at the expense of program size. The code uses all optimizations.
- Space:
- Optimizes code for space at the expense of execution speed. The code uses all optimizations.
- Custom:
- Allows selection of optimizations using the Optimization check boxes.
- None:
- Turns off all Optimization check boxes. No optimization is performed.
Optimizations
The Optimization check boxes control the individual optimizations. These options relate only to the Custom radio button.For more information on how Digital Mars C++ optimizes code, see the Compiler and Tools Guide.
C++ inlining
Controls inline function expansion in C++. When debugging C++ files, the presence of inline code can present considerable problems to most symbolic debuggers. This option suppresses the production of inline code.Windows Prolog/Epilog
The Windows Prolog/Epilog subpage (Figure 16-6) specifies the type of Windows prolog and epilog code that the compiler attaches to each far function in a compilation.
[Figure 16-6 Windows Prolog/Epilog subpage
The first group of radio buttons selects from predefined sets of prolog/epilog options.
Set EXE defaults
Sets options to generate prologs and epilogs for a protected-mode Windows application, with callback functions all marked as _export.Set DLL defaults
Sets options to generate prologs and epilogs for a protected-mode Windows DLL, with callback and exported functions all marked as _export.Real mode full prolog/epilog
Sets options to generate prologs and epilogs for a real or protected-mode Windows application or DLL.Real mode reduced
Sets options to generate prologs and epilogs for a real or protected-mode Windows application or DLL with exported and callback functions (marked with _export).Real mode smart callbacks
Sets options to generate prologs and epilogs for a real or protected-mode Windows application with smart callbacks. In smart callbacks, the compiler compiles far functions with a smart prolog and epilog that loads the data segment from the stack segment. Use smart callbacks only with applications in which the data segment is the same as the stack segment (DS== SS). Do not use it with DLL files.Custom
Specifies a nonstandard set of prolog/epilog options.The remaining options on the Windows prolog/epilog subpage are discussed in the Compiler and Tools Guide.
Output
The Output subpage (Figure 16-7) controls the output generated by the compiler.
[Figure 16-7 Output subpage
Source listing files
With this option on, the compiler creates a source listing file; its name is that of the source file with the extension .lst. The compiler inserts error messages and line numbers in the listing file.Verbose
Displays source and header file names, classes, function prototypes, and time of execution during compilation.Macro expansions
Tells the compiler to create macro expansions in error listings.Assembly listing (.cod)
Causes the compiler to generate a .cod file containing an assembly language representation of the program.Warnings
The options on this subpage, shown in Figure 16-8, control how the compiler produces warnings and enables the compiler to generate only specific warnings.
[Figure 16-8 Warnings subpage]
Warnings
Determines the warning messages that are produced:- All:
- All warnings are produced. Turns on all warnings in the Selected Warnings group.
- Selected:
- Only warnings that have been checked in the Selected Warnings area are produced.
- None:
- No warnings are produced. Turns off all warnings in the Selected Warnings group.
Treat warnings as errors
Causes the compiler to promote warnings to errors. Setting this option allows using the error window to find warnings in the source file.Turn off error maximum
Makes the compiler continue rather than stop when its error limit is reached. The compiler processes the entire source file and displays all errors it has detected.Selected warnings
Determines the warning messages that are produced. For more information on the specific warnings, refer to the Compiler and Tools Guide.Debug Information
The Debug Information subpage (Figure 16-9) controls the information the compiler places into the code for debugging. These options specify the level of debugging, debug information, and other conditions.
[Figure 16-9 Debug Information subpage
Debug information
These radio buttons select from predefined sets of debug information options.- Full:
- Turns on all debug information. Use this set when the application uses a class library or DLL.
- Reduced:
- Turns on the most frequently needed debug information. Use this set for most other programs.
- Custom:
- Select the debug information to be included.
- None:
- Turns off all debug information.
Trace prolog/epilog
Adds the user-defined function calls __trace_pro_f and __trace_epi_f to the prolog and epilog, respectively, for each function. The prolog function is called after the stack frame is set up; the epilog function is called just before the stack frame is destroyed.Line numbers
Places line numbers corresponding to the source into the code. Line number information significantly increases the size of the object file.Symbolic debug information
Includes symbol information for all public symbols. Symbols significantly increase the size of the object file.Three additional options become available when Symbolic Debug Information is checked:
- Unreferenced types:
- Generates symbols for unreferenced types (for example, typedefs).
- All referenced classes:
- Forces symbols for all classes that are referenced in DLL files and class libraries to be generated.
- Dynamic C++ types:
- Adds dynamic C++ class type information to classes with virtual functions. To force the production of typing information for a class with no virtual functions, add a dummy function such as virtual void dummy(){} to the class definition.
Make static functions global
Makes all static functions global. The linker then can enter the names of these functions into the map file and place global debugging information in the executable.Linker
The Linker subpage (Figure 16-10) governs the overall behavior of the linker.
[Figure 16-10 Linker subpage
Debug information
Places debugging information in the executable file. This is the normal option for linking an executable for debugging using the IDDE.No default library
Causes the linker to ignore libraries specified in object files.Case sensitive
Causes the linker to be case sensitive.Far call translation
Causes the linker to convert intrasegment far calls to near calls.Reorder segments
Places like segments in contiguous locations.Export by ordinal
For 32-bit output, causes the linker to export symbols by ordinal. For 16-bit output, when this option is on, the name text for every exported symbol is moved from the resident name table to the nonresident name table.Don't export names
Eliminates storage of name text for symbols exported by ordinal.Export, case sensitive
Makes the linker treat the import and export symbols as case sensitive.Export, uppercase
Forces the linker to convert import and export symbols to uppercase.DOSSEG ordering
Causes the linker to perform the special segment ordering used by Microsoft high-level languages.No null DOSSEG
Causes the linker not to offset the first segment by 10.Warn if dups
Causes the linker to warn if there are duplicate symbols in the code.Delete EXE/DLL on error
Deletes target executable if a link error occurs.Create ImpDef
Forces the linker to generate a .din file, which combines export information from source, definition file, and options.Fix DS
Turning this option on has the same effect as putting a FIXDS directive in the .def file.Keep segments in .def order
Causes the linker to keep segments in the order in which they appear in the .def file (Windows only).Requires Windows 3.0
Causes the linker to tag the executable as requiring Windows 3.0 or later to run.Requires Windows 3.1
Causes the linker to tag the executable as requiring Windows 3.1 or later to run.Generate import library
Directs the linker to build an import library (.lib) describing the exported symbols available to be imported from a DLL.Import lib page size
Sets the page size for the Generate Import Library option.Alignment
In conventional MS-DOS executables, causes the header to be rounded up to the specified size. In segmented .exe files, this option governs the page size.Base
Sets the base address of the executable.Entry point
Specifies the program entry point for Win32 applications.Packing & Map File
The Packing & Map File subpage (Figure 16-11) controls the linker's output of cross-reference and map files.
[Figure 16-11 Packing & Map File subpage
Packing
This group of options controls target packing.Win pack
Packs Windows programs.EXE pack
Compresses the executable file.Smart linking
Enables smart linking of object files containing COMDAT records; only referenced COMDAT records are retained.Pack code
Causes the linker to combine code segments. The size textbox specifies the maximum code segment size.Pack data
Causes the linker to combine data segments. The size textbox specifies the maximum data segment size.Map file
These options generate a file containing a list of segments, in the order of their appearance in the module. This group of options controls map file generation.- No map:
- No map file generated.
- Segment map:
- Generates a list of segments, in the order of their appearance in the module.
- Detailed segment map:
- Includes more detail about segment type, the modules that were added, the number of bytes per segment, and where each module begins.
Map file options
These options control the contents of the map file.Cross reference
Causes the linker to generate a cross-reference list in the map file.Line numbers
Controls whether line-number information is contained in the map file.Group information
Enables output of group information.Definitions
The Definitions subpage (Figure 16-12) contains the parameters necessary to create the .def file for an application.
[Figure 16-12 Definitions subpage
Name
Defines the name of the application, which is used by Windows to identify the application. A name is required for all Windows applications.Description
Contains a description of the application. This optional string is placed in a Windows executable. It can be used for version control or to otherwise help identify the application.Heap size
Specifies the size of the application's local heap. The default is 4096. If the application frequently uses the local heap, specify a larger heap size.For Windows 3.1, heap size is a single text field. For Win32s, the field has two parts: Reserve and Commit, where Reserve is optional. Reserve tells Win32s how much heap space to try to get for this application. Commit specifies the amount of heap space the application actually needs. The two fields are separated by a comma (,). For example, 100000, 4096 would specify 100000 for Reserve and 4096 for Commit.
Stack size
Defines the size, in bytes, of the executable's stack. The default is 4096 bytes. The stack is used for storing function arguments. It's common to need to increase the stack size, especially for applications containing heavily recursive functions.For Windows 3.1, stack size is a single text field. For Win32s, the field has two parts: Reserve and Commit, where Reserve is optional. Reserve tells Win32s how much stack space to try to get for this application. Commit specifies the stack size the application actually needs.
Stub
Specifies an optional file that defines the executable stub to be placed at the beginning of the executable. When a user tries to run the application from DOS, the stub is executed instead. Many applications use the winstub.exe file supplied with the Windows SDK. Any DOS or DOSX executable can be used.Version
Contains optional version information that becomes part of the executable file.Initialize once
The DLL's initialization routine is called only when the module is initially loaded into memory.Private lib
Creates a private DLL that is called.Initialize process
The DLL's entry point is called when a process attaches.Terminate process
The DLL's entry point is called when a process terminates.Initialize thread
The DLL's entry point is called when a thread attaches.Terminate thread
The DLL's entry point is called when a thread terminates.Segments
This subpage, shown in Figure 16-13, provides segment information for the .def file.
[Figure 16-13 Segments subpage
Segment Type
This option toggles between two option sets: one for code segment, and one for data segment.- Code Segment:
- Shows options for the code segment.
- Data Segment:
- Shows options for the data segment.
Attributes
These options define the attributes for the application.Conforming
Turns on the conforming bits for the segment. This attribute can be set for code segments only.Discardable
Lets the system flush the segment from memory. This attribute can be set for code segments only.Shared
Lets multiple applications use this segment simultaneously (DLLs only). This attribute can be set for both code and data segments.Preload
Loads the segment when the executable file or library is loaded. This attribute can be set for both code and data segments.I/O privilege
Turns on the I/O privilege bit for the segment. This attribute can be set for code segments only.Moveable
Lets the segment be moved when memory is compacted. This attribute can be set for both code and data segments.Access Rights
Select access privileges for a segment.Execute Read
Lets an executable read from or execute a segment, but not write to a segment.Execute Only
Lets an executable execute, but not read or write, the segment. This attribute can be set for code segments only.Read Write
Lets an executable read from a segment, or write to a segment, but not execute a segment.Read Only
Lets an executable read from a segment, but not write to or execute the segment. This attribute can be set for data segments only.Instance
Select the type of data segment generated.Multiple data segments
Forces the generation of multiple data segments.Single data segment
Forces the generation of a single data segment.Mode
Select the type of executable file generated.Protected mode
Causes the application to run in protected mode.Real mode
Causes the application to run in real mode.Imports/Exports
The Imports/Exports subpage (Figure 16-14) defines the names of routines in DLLs that the executable can use. It also defines the names of routines that the target (which must be a library) exports to other programs. The IMPORTS and EXPORTS statements are placed in the .def file.
[Figure 16-14 Imports/Exports subpage
Imports
This section defines the names of routines in DLLs that the application can use.Internal name
Contains the name by which the imported routine is called internally. If omitted, the internal name is the same as the external name.External file
Contains the name of the DLL from which the routine is imported.External name
Contains the name of the DLL routine to be imported.Ordinal
Specifies the ordinal number in the DLL of the routine to be imported. Specify the ordinal or the external name, but not both.Add, Replace, Remove
Clicking on the Add button adds the routine to the list of imported routines. Clicking on the Replace button uses the routine to replace the currently selected routine in the list. Clicking on the Remove button removes the currently selected routine from the list.Exports
This section defines the names of routines that can be exported from the DLL.External name
Contains the name by which the DLL routine will be known to other applications.Internal name
Contains the name of the DLL routine to be exported.Ordinal
Specifies the ordinal number by which the DLL can be referenced in other applications. This is optional unless No name is set.Parameters
Specifies the total number of words occupied by the function's parameters. This option applies only to protected-mode functions with I/O privilege.No data
Specifies that this function does not reference any data. This option applies only to real-mode Windows functions with I/O privilege.No name
Specifies that the function can only be referenced by ordinal number.Memory resident name
Makes the function name memory resident, even though an ordinal number is specified.Private
Causes PRIVATE to be added to the names in the module definition file; this directs the IMPLIB utility to ignore the EXPORTS statements.Add, Replace, Remove
Clicking on the Add button adds the routine to the list of exported routines. Clicking on the Replace button uses the routine to replace the currently selected routine in the list. Clicking on the Remove button removes the currently selected routine from the list.Resource Compiler
The Resource Compiler subpage (Figure 16-15) contains options to control the resource compiler.
[Figure 16-15 Resource Compiler subpage
Error maximum
Makes the resource compiler stop when its error limit is reached. If this option is off, the resource compiler processes the entire source file and displays all errors that have been detected.Use predefined macros
Directs the resource compiler to use all predefined macros for the resource file.Generate warnings
Shows warning messages.Verbose
Shows greater detail when compiling resources.32-bit resources
Specifies creation of 32-bit resource files.Define macros
Specifies macros that should be defined for the resource compilers.Source file listing
Specifies the name of the output listing file to create from the .res script.Default hex language
Specifies the default hexadecimal language for 32-bit resources.Code page
Specifies the code page used to convert strings in 32-bit resources to Unicode (currently unused).International characters
This option specifies how the resource compiler interprets 2-byte Asian language character codes within character constants and strings. That is, if a character code represents the first byte of a 2-byte sequence, the second byte is not checked to see whether it is a backslash or a closed quote. The second byte cannot be a NULL (0), a carriage return (0x0D), or an end-of-file (0x1A).- None:
- Allows no 2-byte sequences.
- Japanese:
- Signals the 2-byte sequence with a value in the range 0x81 ... 0x9F and 0xE0 ... 0xFC.
- Taiwanese/Chinese:
- Signals the 2-byte sequence with a value in the range 0x81 ... 0xFC.
- Korean:
- Signals the 2-byte sequence with a value in the range 0x81 ... 0xFD.
Make
The Make subpage (Figure 16-16) sets Make options for the IDDE built-in Make.
[Figure 16-16 Make subpage
The radio buttons at the top of the dialog box control the Make program that will be run when the IDDE builds the project.
- Use IDDE make:
- Use the built-in IDDE make tool.
- Use external make file:
- Use an external Make program.
IDDE make options
This group of options governs the IDDE Make.Build order
Opens the Build Order dialog box (see Figure 16-17).Link order
Opens the Link Order dialog box (see Figure 16-18).Track dependencies
Specifies whether or not to track dependencies (enabled by default). More time is required to track dependencies for large projects with many include files. The most effective way to use this option to establish the correct dependencies is to turn it on when first building a project. Then turn it off, except when changing the dependency structure (by changing #include statements, for example).If dependencies are tracked, the dependent files are shown in the Project window.
Track system includes
Specifies whether to track dependencies in system include files (disabled by default).On error continue unrelated
Causes the IDDE Make to continue to build modules that are not dependent on the module in which the error occurred.Ignore errors in build
Directs the IDDE Make to ignore errors and continue to build the target.Multitasking
Affects the responsiveness of the system to a command to execute another task within Windows while the project is being built.- Frequent:
- Causes the IDDE to frequently give up time slices so other applications can execute faster.
- Moderate:
- Causes the IDDE to give up some of the time to other applications.
- None:
- Turns off multitasking. Other applications are suspended while the IDDE is building a project.
Netbuild
The IDDE allows the build process to be distributed among one or more remote servers. For more information, see Appendix C, "Using NetBuild."Use NetBuild
Enables distributed builds.Use remote headers
Allows the remote server to use the header files provided with Digital Mars C++ on the build server. When this option is off, the build server takes the files from the local machine.Working directory
Specifies the working directory on the remote server.Remote password
Specifies the password for logging on to the remote server.Build order
The Build Order button is only enabled when .prj, .bat, or .mak files are in the project. Clicking on this button opens the Build Order dialog box, shown in Figure 16-17.
[Figure 16-17 Build Order dialog box]
The Build Order dialog box specifies the stage of the build in which the .prj, .bat, or .mak files are executed. Do this by selecting a file from the Build File Pool list, clicking on one of the build steps on the right, then clicking on Add. The selectable steps are:
- Step 1:
- Happens before any compilation takes place.
- Step 3:
- Happens after the files have been compiled into object files, but before they have been linked to make the target.
- Step 5:
- Happens after the final executable has been linked. Return any of the files to the Build File Pool list by selecting the filename in one of the steps and clicking on Remove.
Link order
The Link Order button opens the Link Order dialog box, shown in Figure 16-18.
[Figure 16-18 Link Order dialog box]
The Link Order dialog box specifies the order in which libraries and object files added explicitly to the project are linked. Do this by iteratively selecting files from the LIBs in Project or the OBJs in Project listbox, then clicking Add to move the files to the Link Order listbox.
Return a file to the LIBs in Project or the OBJs in Project listbox by selecting the filename and clicking on Remove.
The libraries added explicitly to the project are linked before other libraries. The object files added explicitly to the project are by default linked after the object files generated by compiling source files in the project. To specify object files to be linked before any other object files use the Prepended linker input files textbox.
When done with the link order, click OK to return to the Make subpage.
External Make
The options on this subpage govern the use of a make utility other than IDDE Make. Figure 16-19 shows the External Make subpage.
[Figure 16-19 External Make subpage]
Using external make
To use a separate external Make program:- Select Use External Make File.
- Specify the .exe name of the Make program in the Make Command Line textbox, followed by any arguments. The IDDE expects the program's directory to be in the PATH environment variable.
- To set the Make's default directory, enter the change in the Initial Directory box. By default, this is the directory that contains Make.
- Use a Windows PIF file to further customize the way Make behaves.
The radio buttons at the top of the dialog box control the Make program that will be run when the IDDE builds the project:
- Use IDDE make:
- Use the built-in IDDE make tool.
- Use external make file:
- Use an external Make program.
Make command line
The Make Command Line textbox holds the .exe name of the external Make program followed by any arguments.Initial directory
Use this textbox to specify the directory from which the Make utility will run.Librarian
The Librarian subpage (Figure 16-20) specifies options for building a library.
[Figure 16-20 Librarian subpage]