[Home]
[Search]
[CTG]
[RTL]
[IDDE]
[STL]
Last update Sep 18, 2002
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 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, 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
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
This option also works 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
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.
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
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.
When done 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 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 next time the Build or Rebuild All command is selected,
the IDDE runs the external 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:
- 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]
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.
Copyright © 1995-2002 Digital Mars. All Rights Reserved.