IPnom Home • Manuals • ClearCase

# Rational ClearCase Commands Reference

Keyword Live Search (10 results max):
Type in part of a ClearCase command in the search box.

## makefile_ccase

makefiles processed by clearmake

### APPLICABILITY

ProductCommand type
ClearCasegeneral information
ClearCase LTgeneral information

Platform
UNIX
Windows

### DESCRIPTION

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.

#### Build Options Specification Files

A build options specification (BOS) file is a text file that contains macro definitions and/or ClearCase special targets. We recommend that you place in a BOS file the temporary macros—such as CFLAGS=–g (UNIX) and CFLAGS=/Zi (Windows)—and others macros that are not to be included in a makefile permanently, rather than specify them on the clearmake command line.

By default, clearmake reads BOS files in this order:

1. The default BOS files
1. 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.
2. 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
2. BOS files specified in the CCASE_OPTS_SPECS environment variable.
3. 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 about the contents of BOS files, see “BOS File Entries”

#### Format of Makefiles

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.

Note: On UNIX, 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 one or two characters to any command, 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:

1. Target-dependent macro definitions
2. Macros specified on the clearmake command line
3. Make macros set in a BOS file
4. Make macro definitions in a makefile
5. 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.

For a list of build-related environment variables, see Building Software.

##### 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.

For example, on UNIX:

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

And on Windows:

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, .o is sometimes used 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 lib(file.o), the name of the member, file.o, appears in the list.$% (Defined only when the target is an archive library member) For a target of the form lib(file.o), $@ evaluates to lib and$% evaluates to the library member, file.o. 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) cc -o supersort ...On Windows:supersort: main.obj sort.obj cmd.obj$(MAKEFILE))   link /out:$@$?
##### 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 $<. #### Special Targets 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: NameMatches 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. .DEFAULT : If a file must be built, but there are no explicit commands or relevant built-in rules to build it, the commands associated with this target are used (if it exists). .IGNORE : Same effect as the –i option. .PRECIOUS : tgt ... The specified targets are not removed when an interrupt character (typically CTRL+C) is typed (also on UNIX, a quit character, which is typically CTRL+\). .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”. .DEPENDENCY_IGNORED_FOR_REUSE: file ... The dependencies you specify are ignored when clearmake determines whether a target object in a VOB is up to date and can be reused. By default, clearmake considers that a target cannot be reused if its dependencies have been modified or deleted since it was built. This target applies only to reuse, not to winkin. Also, this target applies only to detected dependencies, which are not declared explicitly in the makefile. You can specify the list of files with a tail-matching pattern; for example, Templates.DB/%.module (UNIX) or %.module (Windows). Unlike the files listed in most special targets, the files on this list refer to the names of dependencies and not the names of targets. As such, the special target may apply to the dependencies of many targets at once. This special target is most useful when identifying a class of dependencies found in a particular toolset for which common behavior is desired across all targets that have that dependency. .INCREMENTAL_REPOSITORY_SIBLING: file ... The specified files are incremental repository files created as siblings of a primary target and may contain incomplete configuration information. This special target is useful in situations where a toolset creates an incremental sibling object and you want to prevent clearmake from winking in a primary target that has this sibling. If you have an incremental sibling and do not use .INCREMENTAL_REPOSITORY_SIBLING, you could inadvertantly wink it in; this could be a serious problem if the sibling overwrites your view's version of that sibling. You can specify the list of files with a tail-matching pattern; for example, %.pdb. Unlike the files listed in most special targets, the files on this list refer to the names of sibling objects and not the names of targets. As such, the special target may apply to the siblings of many targets at once. This special target is most useful when identifying a class of siblings found in a particular toolset for which common behavior is desired across all targets that have that sibling. .INCREMENTAL_TARGET: tgt ... Performs incremental configuration record merging for the listed targets; in other words, combines dependency information from instances of this target generated previously with the current build of this target. This special target is most useful when building UNIX library archives or Windows libraries, because typically only some of the objects going into a library are read each time the library is updated. You can specify the list of files with a tail-matching pattern; for example, %.a or %.lib. Note: .INCREMENTAL_TARGET applies only to makefile targets built incrementally using a single make rule. Do not use it for the following kinds of files: • Files built incrementally that are not makefile targets. For example, sibling objects like log files or template repositories. • Files built incrementally from several different build scripts. The general guideline is that if you're not building a library in a single makefile rule and you're not building an executable using an incremental linker, then you should not use .INCREMENTAL_TARGET. .NO_CMP_NON_MF_DEPS : tgt ... The specified targets are built as if the –M option were specified; if a dependency is not declared in the makefile, it is not used in configuration lookup. You can specify the list of files with a tail-matching pattern; for example, %.o. .NO_CMP_SCRIPT : tgt ... The specified targets are built as if the –O option were specified; build scripts are not compared during configuration lookup. This is useful when different makefiles (and, hence, different build scripts) are regularly used to build the same target. You can specify the list of files with a tail-matching pattern; for example, %.o. .NO_CONFIG_REC : tgt ... The specified targets are built as if the –F option were specified; modification time is used for build avoidance, and no CRs or derived objects are created. You can specify the list of files with a tail-matching pattern; for example, %.o. .NO_DO_FOR_SIBLING: file ... Disables the creation of a derived object for any file listed if that file is created as a sibling derived object (an object created by the same build rule that created the target). These sibling derived objects are left as view-private files. You can specify the list of files with a tail-matching pattern; for example, ptrepository/_% (UNIX) or %.tmp (Windows). Unlike the files listed in most special targets, the files on this list refer to the names of sibling objects and not to the names of targets. As such, the special target may apply to the siblings of many targets at once. This special target is most useful when identifying a class of siblings found in a particular toolset for which common behavior is desired across all targets that have that sibling. .NO_WINK_IN : tgt ... The specified targets are built as if the –V option were specified; configuration lookup is restricted to the current view. You can specify the list of files with a tail-matching pattern; for example, %.o. .SIBLING_IGNORED_FOR_REUSE: file ... The files are ignored when clearmake determines whether a target object in a VOB is up to date and can be reused. This is the default behavior, but this special target can be useful in conjunction with the .SIBLINGS_AFFECT_REUSE special target or –R command-line option. This target applies only to reuse, not to winkin. You can specify the list of files with a tail-matching pattern; for example, Templates.DB/%.module (UNIX) or %.sbr (Windows). Unlike the files listed in most special targets, the files on this list refer to the names of sibling objects and not the names of targets. As such, the special target may apply to the siblings of many targets at once. This directive is most useful when identifying a class of siblings found in a particular toolset for which common behavior is desired across all targets that have that sibling. .SIBLINGS_AFFECT_REUSE: Build as if the –R command line option were specified; examine sibling derived objects when determining whether a target object in a VOB can be reused (is up to date). By default, when determining whether a target is up to date, clearmake ignores modifications to objects created by the same build rule that created the target (sibling derived objects). This directive tells clearmake to consider a target out of date if its siblings have been modified or deleted. ##### Target for UNIX Only You can use the following target only in UNIX makefiles or BOS files. .NOTPARALLEL :tgt ... Without any tgt arguments, disables parallel building for the current makefile. clearmake builds the entire makefile serially, one target at a time. With a set of tgt arguments, prevents clearmake from building any of the targets in the set in parallel with each other. However, targets in a set can be built in parallel with targets in a different set or with any other targets. For example: .NOTPARALLEL:%.a NOTPARALLEL:foobar clearmake does not build any .a file in parallel with any other .a file, and foo is not built in parallel with bar. However, clearmake may build .a files in parallel with foo or bar. .NOTPARALLEL does not affect lower-level builds in a recursive make, unless you specify it in the makefiles for those builds or include it in a BOS file. You can specify the list of files with a tail-matching pattern; for example, %.a. #### Using Makefiles on UNIX Snapshot Views 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.

#### Sharing Makefiles Between UNIX and Windows

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.

#### Using Makefiles on Windows

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 7 describes makefile requirements for the different MVFS settings.

Table 7. MVFS Settings and Case Requirements for Makefiles

MVFS settingBuild tool and MVFS behaviorMakefile requirements
Case-insensitive and case preservingThe 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-preservingThe 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-preservingThe 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 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:

CMAKE_PNAME_SEP = /

You can set CMAKE_PNAME_SEP in the makefile, in the BOS file, on the command line, or as an environment variable.

#### BOS File Entries

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

For example, on UNIX:

CDEBUGFLAGS = -g

and on Windows:

CDEBUGFLAGS = /Zi

##### 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 on UNIX:

foo.o bar.o := CDEBUGFLAGS=-g

On Windows:

foo.o bar.o := CDEBUGFLAGS=/Zi

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, on UNIX:

BUILD_DATE :sh = date

On Windows:

NT_VER :sh = VER

##### 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.optionss
include $(OPTS_DIR)/pm_build.options On Windows: include \lib\aux.options sinclude$(OPTS_DIR)\pm_build.options

A BOS file can contain comment lines, which begin with a number sign (#).