Makefiles Description

The dmake tool uses makefile.mk.

The following sections describe the general structure of makefile.mk makefiles.

• General Structure of makefile.mk Makefiles
• Generation of Object Files and Libraries
• Generation of Resource Files
• Generation of Applications
• Generation of Shared Libraries or Dynamic Link Libraries
• Internal Structure of the Makefiles
  • The settings.mk file
  • The target.mk file
• Setting Additional Options
• Creation of Additional Targets
  • Add Targets to all
  • Adding Targets to a Makefile That Include Targets
  • Declaring Dependencies Before Adding Targets

General Structure of makefile.mk Makefiles

The general outline of makefiles is as follows:

PRJ=..

PRJNAME=SW

TARGET=core

.include:settings.mk

# use the predefined macros

.include:target.mk

      

The following table describes the macros you use in the general outline of a makefile.

Generation of Object Files and Libraries

The following table describes the macros you use to generate object files and libraries. The x in these macros signifies a number between one and nine. This specifies support for up to nine different libraries.

Generation of Resource Files

The following table describes the macros you use to generate resource files. The German language resource files are built by default. To support other locales, the environment variable UPDATER must be set to YES and the corresponding locale environment variable RES_language must also be set.

The x in these macro names signifies a number between one and nine. This specifies support for up to nine different resource files.

You can also set the give_me_all_languages environment variable to build resource files for languages. However, this builds resource files for all languages.

Generation of Applications

The following table describes the macros you use to generate applications. The x in these macro names signifies a number between one and nine. This specifies support for up to nine different applications.

Generation of Shared Libraries or Dynamic Link Libraries

The following table describes the macros you use to generate shared libraries or dynamic link libraries (DLLs). The x in these macro names signifies a number between one and nine. This specifies support for up to nine different shared libraries.

The following example shows how you can use these macros:

$(MISC)$/$(SHLxTARGET).flt: 

	@echo string >> $@

Note: The new line and indentation are necessary for these lines to work.

This command generates a filter file for automatically creating a definition file. The ldump tool parses the library specified in DEFLIBxNAME for symbols, removes all symbols that match the string in the *.flt file, and writes the resulting list into the definition file.

You can only do this for Win32. A similar process for Linux, Solaris, and Mac OS X is planned.

Internal Structure of the Makefiles

Each makefile contains an include directive to a settings.mk file, followed by an include directive to a target.mk file. The following sections describe these files.

The settings.mk file

The file settings.mk sets all the global settings for the makefiles. It sets macros, based on the following:

• The underlying operating system.
• The compiler used.
• The version of the office suite you are building.

For example, it sets the name of the compiler used, linker, or library manager. It can also define the names of libraries, compiler switches, and link switches.

In the target.mk file, the standard target is predefined depending on the macros you set. For example, it can contain statements for linking applications, libraries, or resources. Typically, the include directive gets these files from solenv/inc. Typically, the include directive gets these files from solenv/inc.

There are other makefiles that specify particular settings that control parts of the build. The following table describes these special settings makefiles. These makefiles are included by either settings.mk or target.mk.

The target.mk file

After the include of settings.mk, the next major include is the target.mk file which describes how to build the targets of each platform. The target.mk file is divided into the following parts:

1. Expansion of the overall targets.
2. Dependency order.
3. Description of the following individual targets:
   • _tg_def.mk - the definition files for shared libraries (DLLs).
   • _tg_sdi.mk - the target definition for the IDL (svidl) files.
   • tg_obj.mk - the building of the library from object files.
   • tg_slo.mk - the building of the library from .slo files.
   • _tg_lib.mk - the building of the library from any files.
   • _tg_srs.mk - the translation of the .src files.
   • _tg_res.mk - the translation of the .srs files.
   • _tg_rslb.mk - generation of the resource DLLs.
   • _tg_shl.mk - generation of the shared libraries.
   • tg_jar.mk - generation of the jar files.
   • tg_dep.mk - generation of the dependencies.

The file also includes the descriptions of many further targets such as killobj, killbin, and so on.

Setting Additional Options

You use the macros described in the following table to set additional options.

Creation of Additional Targets

The following sections describe ways to create additional targets in a makefile.

Add Targets to all

To build targets other than the default targets that are created by the target.mk file, follow these steps:

1. Add the targets to the target all as dependencies.
2. End the list of targets with ALLTAR.
3. Make sure target all precedes the include of target.mk in the makefile.

If you write your target in a platform independent form without using any hard-coded pathnames, ensure that your target appears before the .include:target.mk directive. If this works, this is an acceptable way to create an additional target.

Adding Targets to a Makefile That Include Targets

The typical way to add a target is to add it to an existing makefile.mk that already includes targets. This causes the following problems:

• If you place your target before the .include:target.mk directive in the makefile, it disables the global targets.
• If you place your target after the .include:target.mk directive, dmake does not build the target.
• If you try to build your target by using the technique in the following sample, you may encounter several other problems.

  all: \ new-target \ ALLTAR

  The first target is always built. When doing an initial build, dmake enters states where no ALLTARis defined and displays an error message and stops.

  There is also no guaranteed order of execution of those two targets. It may work most of the time and produce unusual errors on multiprocessor machines.

Declaring Dependencies Before Adding Targets

Define explicit dependencies as follows:

#this object depends on generated source

$(OBJ)$/myobject.obj : $(MISC)$/myobject.cxx

      

Then define the target to generate the source file after this statement. If this object is needed now, there is a dependency on the source file and the target is executed. You must define all the targets and dependencies after the .include:target.mkdirective.

There is still a potential problem of conflicts with targets added to the global makefiles in the future. If something in the build environment changes and affects your target, it may be difficult to identify the change.