#
$
K
+
Contents
Click on a topic formatted in green to view more information about that topic.
� Getting Started
� Windowsâ NTâ Directory Structure
� Using the Build Utility
� Building Multiple Targets from One Subdirectory
� Multi-processor Build Issues
� Specifying Libraries
� Precompiled Headers
� Environment Variables
� Macro Definitions
� Rules
� Debugging
� Building Windows NT Software
� Building Chicago Software
� Building Win32 Subsystem Software
� Frequently Asked Questions
� Glossary
#
$
K
+
Getting Started
The Build Utility,
build.exe
, was created by
Steve Wood it to build Windows NT. The Build Utility
provides a structured way of building things. This is the default build process for Windows NT.
Groups who use it enable the Windows NT group to be able to build with their group and to
make changes to the group’s source files when needed. Other groups, such as the VC team,
use the Build Utility for precisely this reason. Even though the VC team did not need the same
multi-platform support for their build process as the build process for Windows NT needed, the
Build Utility enabled them to override all the default settings for build.exe and still take
advantage of Windows NT.
See Also
Features
Why Use the Build Utility
Where is the Build Utility Located
Quick Start
#
$
K
Steve Wood
Steve Wood was one of the initial ten people working on Windows NT. They knew that they
were going to build something really, really big. Steve came from OS/2 where everyone used
individual procedures for building products. In OS/2, there were the UI people, the base kernel
people, and the net people, who all had their own way of doing things. The build was
tremendously difficult to coordinate. If you went to one subdirectory, you built a certain way, but
if you went to another subdirectory, you built a different way. There were people in different
geographic locations, all of them making changes and none of them compatible with each other
or working together. So Steve came from that environment and realized there was a need for
something better. That’s how the Build Utility came into being.
The question Steve asked was how could he abstract out all of this complicated gobbeldy-gook
and put it in a master file? Steve noticed that nmake itself does not have some of the functions
needed to build Windows NT: the ability to occasionally exclude directories or only build certain
directories. He also wanted to have a way to have a global look at the whole tree for
Windows NT. If a file changed anywhere in the tree, the developers could easily answer the
question: “What do we have to rebuild as a result of that change?”
One of the things the Build Utility does is create a master database of all the inter-dependencies
in the tree. This means you can go to any subdirectory, make a change to a file, and check it in.
Then you can go to the top of the build tree for Windows NT, run build.exe, and anything in the
tree that needs to be rebuilt, will be rebuilt. You don’t have to worry if you did the right thing.
There would have been no way to build Windows NT without this type of structure and
methodology.
The Build Utility eliminates the requirement of testing every single release against every single
platform. This requirement is not needed for Windows NT because Windows NT performs the
same way on all platforms: Intel, Alpha, MIPS, and PowerPC.
#
$
K
+
Features
The Build Utility:
� Automatically establishes file dependencies.
� Provides tools to build products for multiple hardware platforms without specifying any
target-specific information.
� Shields you from the details of the various compilers and machine architectures.
� Is multiprocessor aware for speedier compilation.
� Provides feedback during compilation, including:
* How much longer before the build will finish
* How many lines are compiling
* How fast it’s compiling them
* How many files you have to link
* How many targets you are creating
� Provides detailed information about the build process.
#
$
K
+
Why Use the Build Utility?
The great benefit to using this Build Utility, rather than creating your own make or nmake files, is
because:
� The Build Utility isolates all target-dependent information in a centralized location (including
header and library include paths, compiler names and switches, and linker switches).
� You can build products for multiple hardware platforms without specifying any target-specific
information.
� The Build Utility ensures that everyone builds consistently.
This is important when you have multiple files to build, many .exe files that you are
generating, and multiple developers working on a project, You never have to be specific
places. Once you are set up in one subdirectory in Windows NT, you can build all your
subdirectories using build.exe. For this reason, the Build Utility has been used successfully
by the following groups: Exchange, VC, Media Foundation, and MSN.
