By now, you should have a pretty good feel for what abuild can do and how to use it in several situations. The remaining chapters of this document cover advanced topics and present examples for solving a wide variety of problems. Although later chapters sometimes build on information presented in earlier chapters, many of the remaining chapters and examples can probably be understood on their own. It should therefore be safe to focus your attention on the material that is of interest or potential use to you.
Part III, “Advanced Functionality” opens with detailed descriptions of abuild's configuration files and interface subsystem. It then continues with explorations of several specific problems. We present here a brief list of problems that are addressed in the remaining chapters:
Abuild includes support for creating shared libraries on UNIX platforms and DLLs on Windows platforms. In Chapter 17, Shared Libraries, we describe the process and explore some of the other concerns you have to consider when using shared libraries with abuild.
There are two chapters that explore how to use code generators with abuild. In Chapter 18, Automatically Generated Code for GNU Make-based Builds, we discuss code generators for make-based builds. In Chapter 19, Java Hooks and Code Generators, we discuss them for ant-based builds. Although the concepts are similar, there are some differences depending on which backend you are using.
In general, abuild is designed such that all build item interfaces automatically inherit through the dependency chain. There are some cases when it may be desirable for a build item to have an expanded interface that is available to certain build items upon request. In Chapter 20, Interface Flags, we introduce a feature of abuild designed to solve this problem and present an example of using it to implement private interfaces.
Abuild's platform system is designed to make building on multiple platforms as easy as possible. If a build item can be built on multiple platforms, abuild will generally sort out all the details of which build of one item another item should depend on. There are times, however, when it is necessary to take control over this behavior. We discuss this problem in Chapter 21, Cross-Platform Support.
We all know that security is increasingly important in the software community. In some cases, it may be necessary to create collections of software that are only allowed to run or even exist in secure environments. In Chapter 22, Build Item Visibility, we describe how to use abuild's build item visibility feature along with externals to create a mixed classification development environment, and we present an example that illustrates one implementation strategy.
Although abuild's Java support is not as mature as its C and C++ support, abuild does include limited support for creation of web archives (WAR files) and enterprise archives (EAR files) for use in Java Enterprise environments. We explore how to create different types of Java archives in Chapter 23, JARs and Other Archives.
Ordinarily, when an application links with a library, only functions that are actually called are linked into the executable. On platforms that support this, abuild allows you to specify that the entire contents of a library archive should be included in an executable. In Chapter 24, Linking With Whole Libraries, we describe why you might want to do this and how to do it.
Some development problems require one interface to be created that opaquely hides another interface. Since abuild's default behavior is to make all interfaces inherit through the dependency chain, special constructs are required to implement opaque wrappers. In Chapter 25, Opaque Wrappers, we present the mechanisms required to make this work.
There are certain tasks that go beyond simply building targets and making them available. Examples include adding support for new compilers and performing extra validations that go beyond what can be easily expressed using abuild's built-in mechanisms. In Chapter 26, Enhancing Abuild with Plugins, we present a plugin framework that can be used to extend abuild in certain ways.
In addition to the above topics, we explore some details of how abuild works behind the scenes and present guidelines for how to use abuild in the safest and most effective way. The table of contents at the beginning of Part III, “Advanced Functionality” includes a complete list of chapters, and each chapter starts with some introductory text that describes the material it covers.