www.digitalmars.com [Home] [Contents] [Prev] [Next]

16. More about Project Build Settings


This chapter details the options for controlling how your project is 
built. This discussion began in Chapter 15, "More about Projects and 
Workspaces." This chapter lists and explains the options on the Build 
page of the Project Settings dialog box. You 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 you to 
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 your 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 SC, 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, you can 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 


Each of the subpages is described in a separate section in this 
chapter. 

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 generates C code that conforms to ANSI standards. Refer to the Compiler and Tools Guide for information on the restrictions that take effect when you enable this option. Treat source as C++ With this option selected, the compiler treats C source files as C++ files. The option is useful if you want to: ° Compile the file to take advantage of type-safe linkage ° Link a C file to a C++ file without changing it or giving it a C++-compatible extension You can also use this option on C++ header files with the .h 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 In addition, for 16-bit compilations: ° int == unsigned == enum == short And for 32-bit compilations: ° int == unsigned == enum == long The option is useful for quickly porting code from compilers that do not obey the full set of ANSI type-checking rules. 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 Allows you to specify macro definitions on the compiler command line. You should 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 your 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, you must 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 This lets you control 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 This option lets you create a compilation 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 your program uses 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, you can precompile 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. To maximize compile speed, set the directory to a RAM disk. 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 Lets you select 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. You can 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 you are 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 Lets you specify 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 let you enable 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 you to use 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: Allows you to 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 you if you have duplicate symbols in your 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 your 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 how your target is packed. 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 your 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. You may need to increase the stack size, especially if your application contains 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. You can use one of your own executables instead. 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 These settings let you 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 These settings let you 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 These settings let you 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) lets you define the names of routines in DLLs that your executable can use. It also lets you define the names of routines that your 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 your 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. You can 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 your 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 your 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: Allows you to 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 you first build a project. Then turn it off, except when you change 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 your 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 your 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 you have .prj, .bat, or .mak files in your 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 lets you specify the stage of the build in which you want your .prj, .bat, or .mak file executed. You 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 steps you can select are as follows: Step 1: Happens before any compilation takes place. Step 3: Happens after your files have been compiled into the object files, but before they have been linked to make the target. Step 5: Happens after your final executable has been linked. You can return any of the files to the Build File Pool list by selecting the filename in one of the steps and clicking on Remove. When you are satisfied with the build order, click OK to return to the Make subpage. 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 lets you specify the order in which libraries and object files added explicitly to the project are linked. You 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. You can 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. You can specify object files to be linked before any other object files in the Prepended linker input files textbox. When you are satisfied 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 your own Make program: 1. Select Use External Make File. 2. Specify the .exe name of your Make program in the Make Command Line textbox, followed by arguments, if any. The IDDE expects the program's directory to be in the PATH environment variable. 3. If you want to change the Make's default directory, enter the change in the Initial Directory box. By default, this is the directory that contains Make. 4. You can use a Windows PIF file to further customize the way Make behaves. The next time you use the Build or Rebuild All command, the IDDE runs your Make program from a DOS command-line window, which closes when Make is done. 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: Allows you to use an external Make program. Make command line The Make Command Line textbox holds the .exe name of your Make program followed by arguments, if any. 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 Ignore case Directs the librarian utility to ignore case in symbols. Do not create backup Keeps the librarian utility from backing up the original library. When this option is turned off, the original library is saved in a backup file. Page size Specifies the library page-swapping size.