makefiles processed by clearmake
Product | Command Type |
---|---|
ClearCase | general information |
ClearCase LT | general information |
Platform |
---|
UNIX |
Windows |
NOTE: The distinctive features of clearmake, such as build auditing, derived object sharing, and build avoidance, are supported in dynamic views only. In addition, while parallel building is supported in ClearCase snapshot views, it is not supported in ClearCase LT.
A makefile contains a sequence of entries, each of which specifies a build target, some dependencies, and the build scripts of commands to be executed. A makefile can also contain make macro definitions, target-dependent macro definitions, and build directives (special targets.)
Target/dependencies line. The first line of an entry is a white-space-separated, nonnull list of targets, followed by a colon (:) or a double colon (::), and a (possibly empty) list of dependencies. Both targets and dependencies may contain ClearCase pathname patterns. (See the wildcards_ccase reference page.)
The list of dependencies may not need to include source objects, such as header files, because clearmake detects these dependencies. However, the list must include build-order dependencies, for example, object modules and libraries that must be built before executables.
Build script. Text following a semicolon (;) on the same line, and all subsequent lines that begin with a <TAB> character, constitute a build script: a set of commands to be executed in a shell (UNIX) or command interpreter (Windows). A command can be continued onto the next text line with a \<NL> sequence. Any line beginning with a number sign (#) is a comment.
A build script ends at the first nonempty line that does not begin with a <TAB> or number sign (#); this begins a new target/dependencies line or a make macro definition.
Build scripts must use standard pathnames only. Do not include view-extended or version-extended pathnames in a build script.
Executing a build script updates the target, and is called a target rebuild. The commands in a build script are executed one at a time, each in its own instances of the subshell or command interpreter.
clearmake always completely eliminates a \<NL> sequence, even in its compatibility modes. Some other make programs sometimes preserve such a sequence-for example, in a UNIX sed(1) insert command:
target: depdcy
sed -e '/xxx=0/i\
yyy=xxx;' depdcy > target
Make macro. A make macro is an assignment of a character-string value to a simple name. By convention, all letters in the name are uppercase (for example, CFLAGS).
Target-dependent macro definitions. A target-dependent macro definition takes the form target-list := macro_name = string
You can use macros in makefiles or in BOS files. For more information, see BOS File Entries.
Special targets. A line that begins with a dot (.) is a special target, which acts as a directive to clearmake.
A build options specification (BOS) file is a text file containing macro definitions and/or ClearCase special targets. We recommend that you place temporary macros-such as CFLAGS=-g (UNIX) and CFLAGS=/Zi (Windows)-and others not to be included in a makefile permanently in a BOS file, rather than specifying them on the clearmake command line.
By default, clearmake reads BOS files in this order:
The default BOS files
The file .clearmake.options in your home directory as indicated in the password database (UNIX) or by the HOME environment variable or in the user profile (Windows). This is the place for macros to be used every time you execute clearmake.
One or more local BOS files, each of which corresponds to one of the makefiles specified with a -f option, or read by clearmake. Each BOS file has a name in the form makefile-name.options. For example:
makefile.options |
Makefile.options |
project.mk.options |
BOS files specified in the CCASE_OPTS_SPECS environment variable.
BOS files specified on the command line with -A.
If you specify -N, clearmake does not read default BOS files.
clearmake displays the names of the BOS files it reads if you specify the -v or -d option, or if CCASE_VERBOSITY is set to 1.
For information on the contents of BOS files, see BOS File Entries.
The following sections describe the special considerations for using makefiles with clearmake.
Restrictions-clearmake does not support the use of standard input as a makefile.
Libraries-If a target or dependency name contains parentheses, it is assumed to be an archive (library) created by ar(1) (UNIX), lib (Windows), or some other librarian. The string within parentheses refers to a member (object module) within the library. Use of function names within parentheses is not supported.
For example, on UNIX:
lib.a : lib.a(mod1.o) lib.a(mod2.o)
Thus, lib.a(mod1.o)refers to an archive that contains object module mod1.o. The expression lib.a(mod1.o mod2.o) is not valid.
Similarly, on Windows:
hello.lib : hello.lib(mod1.obj) hello.lib(mod2.obj)
hello.lib(mod1.obj) refers to an archive that contains mod1.obj. The expression hello.lib(mod1.obj mod2.obj) is not valid.
Inference rules for archive libraries have the form:
UNIX: .sfx.a
Windows: .sfx.lib
where sfx is the file-name extension (suffix) from which the archive member is to be made.
The way in which clearmake handles incremental archive construction differs from other make variants.
UNIX NOTE: The u key for ar is not reliable within a ClearCase environment. Do not use it.
Command Echoing and Error Handling-You can control the echoing of commands and the handling of errors that occur during command execution on a line-by-line basis, or on a global basis.
You can prefix any command with one or two characters, as follows:
- | Causes clearmake to ignore any errors during execution of the command. By default, an error causes clearmake to terminate. The command-line option -i suppresses termination-on-error for all command lines. |
@ | Suppresses display of the command line. By default, clearmake displays each command line just before executing it. The command-line option -s suppresses display of all command lines. The -n option displays commands, but does not execute them. |
-@ @- | These two prefixes combine the effect of - and @. |
The -k option provides for partial recovery from errors. If an error occurs, execution of the current target (that is, the set of commands for the current target) stops, but execution continues on other targets that do not depend on that target.
Built-In Rules-File-name extensions (suffixes) and their associated rules in the makefile override any identical file-name extensions in the built-in rules. clearmake reads built-in rules from the file builtin.mk when you run in standard compatibility mode. In other compatibility modes, other files are read.
Include Files-If a line in a makefile starts with the string include or sinclude followed by white space (at least one <SPACE> or <TAB> character), the rest of the line is assumed to be a file name. (This name can contain macros.) The contents of the file are placed at the current location in the makefile.
For include, a fatal error occurs if the file is not readable. For sinclude, a nonreadable file is silently ignored.
Order of Precedence of Make Macros and Environment Variables-By default, the order of precedence of macros and environment variables is as follows:
Target-dependent macro definitions
Macros specified on the clearmake command line
Make macros set in a BOS file
Make macro definitions in a makefile
Environment variables
For example, target-dependent macro definitions override all other macro definitions, and macros specified on the clearmake command line override those set in a BOS file.
If you use the -e option to clearmake, environment variables override macro definitions in the makefile.
All BOS file macros (except those overridden on the command line) are placed in the build script's environment. If a build script recursively invokes clearmake:
The higher-level BOS file setting (now transformed into an EV) is overridden by a make macro set in the lower-level makefile. However, if the recursive invocation uses clearmake's -e option, the BOS file setting prevails.
If another BOS file (associated with another makefile) is read at the lower level, its make macros override those from the higher-level BOS file.
See Building Software for a list of build-related environment variables.
Make Macros-A macro definition takes this form:
macro_name = string
Macros can appear in the makefile, on the command line, or in a build options specification file. (See Build Options Specification Files.)
Macro definitions require no quotes or delimiters, except for the equal sign (=), which separates the macro name from the value. Leading and trailing white space characters are stripped. Lines can be continued using a \<NL> sequence; this sequence and all surrounding white space is effectively converted to a single <SPACE> character. macro_name cannot include white space, but string can; it includes all characters up to an unescaped <NL> character.
clearmake performs macro substitution whenever it encounters either of the following in the makefile:
$(macro_name)
$(macro_name:subst1=subst2)
It substitutes string for the macro invocation. In the latter form, clearmake performs an additional substitution within string: all occurrences of subst1 at the end of a word within string are replaced by subst2. If subst1 is empty, subst2 is appended to each word in the value of macro_name. If subst2 is empty, subst1 is removed from each word in the value of macro_name.
% cat Makefile
C_SOURCES = one.c two.c three.c four.c
test:
echo "OBJECT FILES are: $(C_SOURCES:.c=.o)"
echo "EXECUTABLES are: $(C_SOURCES:.c=)"
% clearmake test
OBJECT FILES are: one.o two.o three.o four.o
EXECUTABLES are: one two three four
z:\myvob> type Makefile
C_SOURCES = one.c two.c three.c four.c
test:
echo OBJECT FILES are: $(C_SOURCES:.c=.obj)
echo EXECUTABLES are: $(C_SOURCES:.c=.exe)
z:\myvob>
clearmake test
OBJECT FILES are: one.obj two.obj three.obj four.obj
EXECUTABLES are: one.exe two.exe three.exe four.exe
NOTE: UNIX and Windows object files have different file extension naming conventions: .o for UNIX and .obj for Windows. Where this distinction is not important for the purposes of these discussions, we sometimes use .o to designate any object file in this reference page.
Internal Macros-clearmake maintains these macros internally. They are useful in rules for building targets.
$* | (Defined only for inference rules) The file name part of the inferred dependency, with the file-name extension deleted. |
$@ | The full target name of the current target. |
$< | (Defined only for inference rules) The file name of the implicit dependency. |
$? | (Defined only when explicit rules from the makefile are evaluated) The list of dependencies that are out of date with respect to the target. When configuration lookup is enabled (default), it expands to the list of all dependencies, unless that behavior is modified with the .INCREMENTAL_TARGET special target. In that case, $? expands to the list of all dependencies different from the previously recorded versions. When a dependency is an archive library member of the form |
$% | (Defined only when the target is an archive library member) For a target of the form |
MAKE | The name of the make processor (that is, clearmake). This macro is useful for recursive invocation of clearmake. |
MAKEFILE | During makefile parsing, this macro expands to the pathname of the current makefile. After makefile parsing is complete, it expands to the pathname of the last makefile that was parsed. This holds only for top-level makefiles, not for included makefiles or for built-in rules; in these cases, it echoes the name of the including makefile. Use this macro as an explicit dependency to include the version of the makefile in the CR produced by a target rebuild. On UNIX: supersort: main.o sort.o cmd.o $(MAKEFILE) On Windows: supersort: main.obj sort.obj cmd.obj $(MAKEFILE) |
VPATH Macro-The VPATH macro specifies a search path for targets and dependencies. clearmake searches directories in VPATH when it fails to find a target or dependency in the current working directory. clearmake searches only in the current view. The value of VPATH can be one directory pathname, or a list of directory pathnames separated by colons (UNIX) or semicolons (Windows). (In Gnu compatibility mode, you can also use spaces as separators.)
Configuration lookup is VPATH-sensitive when qualifying makefile dependencies (explicit dependencies in the makefile). Thus, if a newer version of a dependent file appears in a directory on the search path before the pathname in the CR (the version used in the previous build), clearmake rejects the previous build and rebuilds the target with the new file.
The VPATH setting may affect the expansion of internal macros, such as $<.
Like other build tools, clearmake interprets certain target names as declarations. Some of these special targets accept lists of patterns as their dependents, as noted in the description of the target. Pattern lists may contain the pattern character, %. When evaluating whether a name matches a pattern, the tail of the prefix of the name (subtracting directory names as appropriate) must match the part of the pattern before the %; the file-name extension of the name must match the part of the pattern after the %. For example:
Name | Matches | Does not match |
---|---|---|
(UNIX) /dir/subdir/x.o | %.o x.o subdir/%.o subdir/x.o | /dir/subdir/otherdir/x.o |
(Windows) \dir\subdir\x.obj | %.obj x.obj subdir\%.obj subdir\x.obj | \dir\subdir\otherdir\x.obj |
The following targets accept lists of patterns:
.DEPENDENCY_IGNORED_FOR_REUSE
.INCREMENTAL_REPOSITORY_SIBLING
.INCREMENTAL_TARGET
.NO_CMP_NON_MF_DEPS
.NO_CMP_SCRIPT
.NO_CONFIG_REC
.NO_DO_FOR_SIBLING
.NO_WINK_IN
.SIBLING_IGNORED_FOR_REUSE
Special Targets for Use in Makefiles-You can use the following special targets in the makefile.
.SILENT :
Same effect as the -s option.
Special Targets for Use in Makefiles or BOS Files-You can use the following special targets either in the makefile itself or in a build options specification file. See Build Options Specification Files.
|
|
UNIX-Only Target-You can use the following target only in UNIX makefiles or BOS files.
Because snapshot views do not make use of the MVFS, absolute VOB pathnames (for example, /vobs/tools/foo.h) are not supported in snapshot views on UNIX. For that reason, your makefiles must not include absolute VOB pathnames.
To eliminate absolute VOB pathnames from makefiles, use the pwv -root command to get the value of the current view-root directory. Use that value in one of the following methods:
Pass the context-dependent view root to the makefile from an external definition (for example, with Imake).
Define the context-dependent view root in the makefile. For example:
VWROOT=`cleartool pwv -root`
TOOLS=$(VWROOT)/vobs/tools
The method shown in this example works for any clearmake compatibility mode. There are also methods specific to each compatibility mode. See your make documentation for more information.
clearmake is available on both UNIX and Windows NT. In principle, you can write portable makefiles, but in practice, the obstacles are substantial. The variations in tool and argument names between systems makes writing portable build scripts particularly challenging. If you choose to pursue portable makefiles, use the following general procedures to produce usable results.
Start on UNIX; avoid most compatibility modes-Windows NT clearmake supports Gnu compatibility mode but does not support others (for example, Sun compatibility mode). Instead, it supports basic make syntax. To write or tailor transportable makefiles, begin makefile development on UNIX, without compatibility modes other than Gnu in effect. Gnu generates errors and warnings for problematic syntax. When things work cleanly on UNIX, move your makefiles to Windows NT for testing.
Use a makefile-generating utility, such as imake, to generate makefiles-Use imake or some other utility to generate the makefiles you will need, including clearmake makefiles for Windows NT.
There are several rules to follow when constructing, or converting, makefiles for use by clearmake on a Windows host. Note that, as a general rule, your makefiles must match the syntax required by clearmake on UNIX.
The following sections describe how you must specify build macros, targets, and dependencies in makefiles to avoid case problems.
Build Macros and Case-Sensitivity-clearmake is case-sensitive with respect to makefile macros. Consider a makefile macro reference, $(CPU)
. There are numerous input sources from which to satisfy this macro:
From the makefile itself
From the current table of environment variables
From the command line
From a build option specification (BOS) file
For any macro to be expanded correctly from any of these sources, the macro definition and macro reference must be in the same case. For example, $(CPU)
is not replaced by the value of an EV named cpu.
Makefile Target/Dependency Pathnames-When you write makefiles, you must be aware of the MVFS setting on your computer and specify targets and dependencies accordingly. If the MVFS is case-preserving, you must use case-correct pathnames in makefiles to guarantee the consistency of the resulting config records. Even if your MVFS is not case-preserving, we recommend that you use case-correct pathnames so that users on case-preserving computers can share the makefile.
NOTE: The -d option to clearmake warns you when case is the only difference in pathnames in the makefile and on the file system.
Table 11 describes makefile requirements for the different MVFS settings.
MVFS Setting | Build Tool and MVFS Behavior | Makefile Requirements |
---|---|---|
Case-insensitive and case preserving | The MVFS preserves the case of created files. The build tool looks for the file as it is specified in the makefile. | The case of the target must match the case of the file produced by the MVFS. |
Case-insensitive and non-case-preserving | The MVFS converts the names of all files created to lowercase. The build tool looks for a lowercase file name. | The case of the target does not matter. |
Case-sensitive and case-preserving | The MVFS preserves the case of created files. The build tool looks for the file as it is specified in the makefile. | The case of the target must match the case of the file produced by the MVFS. |
Supporting Both omake and clearmake- It is possible, but not trivial, to prepare makefiles that can be used with either omake or clearmake. The general approach is to supply omake-specific macro definitions in the makefile, and to supply clearmake-specific macro overrides in a build options specification (BOS) file; clearmake reads the BOS file, but omake does not. When clearmake executes, it looks for macro definitions in two locations:
%HOME%\.clearmake.options
makefile.options, in the same directory as makefile (substitute the actual name of your makefile, if it is not makefile)
BOS files at other locations can be passed to clearmake with the -A option.
Using UNIX-Style Command Shells in Makefiles-On Windows, clearmake accepts either slashes ( / ) or backslashes ( \ ) in pathnames. However, clearmake uses a backslash as the separator in any pathnames that it constructs in build scripts (for example, as a result of VPATH directory searching). This can cause problems with UNIX-like command shells that require slashes in any pathnames supplied to them in command lines.
If you are using such a shell (for example, by setting the SHELL makefile variable accordingly), you can force clearmake to use slashes when constructing pathnames. To do this, set the CMAKE_PNAME_SEP variable:
You can set CMAKE_PNAME_SEP in the makefile, in the BOS file, on the command line, or as an environment variable.
The following sections describe the entries you can put in BOS files.
Standard Macro Definitions-A standard macro definition has the same form as a make macro defined in a makefile:
macro_name = string
CDEBUGFLAGS = -g (UNIX)
CDEBUGFLAGS = /Zi (Windows)
Target-Dependent Macro Definitions-A target-dependent macro definition takes this form:
target-pattern-list := macro_name = string
Any standard macro definition can follow the := operator; the definition takes effect only when targets matching patterns in target-pattern-list and their dependencies are processed. Patterns in the target-pattern-list must be separated by white space. For example:
foo.o bar.o := CDEBUGFLAGS=-g (UNIX)
foo.o bar.o := CDEBUGFLAGS=/Zi (Windows)
Two or more higher-level targets can have a common dependency. If the targets have different target-dependent macro definitions, the dependency is built using the macros for the first higher-level target clearmake considered building (whether or not clearmake actually built it).
Shell Command Macro Definitions-A shell command macro definition replaces a macro name with the output of a shell command:
macro_name :sh = string
This defines the value of macro_name to be the output of string, any shell command. In command output, <NL> characters are replaced by <SPACE> characters. For example:
BUILD_DATE :sh = date (UNIX)
NT_VER :sh = VER (Windows)
Special Targets-You can use some ClearCase special targets in a build options spec. See Special Targets.
Include Directives-To include one BOS file in another, use the include or sinclude (silent include) directive. For example, on UNIX:
include /usr/local/lib/ux.options
sinclude $(OPTS_DIR)/pm_build.options
include \lib\aux.options
sinclude $(OPTS_DIR)\pm_build.options
Comments-A BOS file can contain comment lines, which begin with a number sign (#).
clearmake, clearmake.options, makefile_aix, makefile_gnu, makefile_pmake, makefile_smake, makefile_sun, omake, Building Software
Feedback on the documentation in this site? We welcome any comments!
Copyright © 2001 by Rational Software Corporation. All rights reserved. |