makefile_ccase

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 and Linux), 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 or Linux:

  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 and Linux: .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.

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:

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 the VersionVault Guide to 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 or Linux:

% 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

Internal macros

clearmake maintains these macros internally. They are useful in rules for building targets.

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 path name or a list of directory path names separated by colons (UNIX and Linux) 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 path name 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 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 and Linux, 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 and Linux) 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.

.DIRECTORY_AFFECTS_REUSE: tgt ...

This special target can be used to specify a declared directory dependency for reuse. It overrides both the .DIRECTORY_IGNORED_FOR_REUSE special target and the CCASE_DIR_IGNORED_REUSE environment variable.

This target takes one or more (white-space-separated) directory path names. You can specify the path names with a %tail-matching pattern.

.DIRECTORY_IGNORED_FOR_REUSE: tgt ...

clearmake notes directories for reuse that are recorded in a config record as dependencies. This target can be used to selectively override a declared directory dependency.

This target takes one or more (white-space-separated) directory path names. You can specify the path names with a %tail-matching pattern.

This special target has an equivalent environment variable called CCASE_DIR_IGNORED_REUSE, which takes no arguments, but is either on or off. If on, this environment variable overrides the build avoidance treatment of all declared directory dependencies.

.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 library archives, 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.

.JAVA_TGTS: file ...

This special target is used to handle subclasses generated by Java™ compilers.

In the makefile, any file name that matches the pattern allows a $ to be escaped by another $. For example, to specify a$x.class:

.JAVA_TGTS: %.class
.java.class:
javac $<
a$$x.class: a.class

Note that $$ mapping to a single $ is default behavior in Gnu make compatibility mode.

You can specify the list of files with a tail-matching pattern; for example, %.class.

.JAVAC:

Use this special target to enable clearmake to use heuristics on audits of Java builds to accurately evaluate .class dependencies. These dependencies are then stored in .class.dep files for future clearmake runs, and they enable those runs to build .class targets in the same order that the Java compiler does.

This special target must be used with no dependencies and no build script:

JAVAC:

Other than that, makefiles must use implicit suffix or pattern rules. For example:

.SUFFIXES: .java .class .java.class:        

rm -f $@        

$(JAVAC) $(JFLAGS) $<

For compatibility modes that support them, use implicit pattern rules. For example:

%.class: %.java         

rm -f $@         

$(JAVAC) $(JFLAGS) $?  

The makefiles must also use absolute paths for .class targets. Clearmake contains a built-in macro function you can use to specify absolute paths:

$(javaclasses)

.MAKEFILES_AFFECT_REUSE:

By default, makefiles recorded by using the .MAKEFILES_IN_CONFIG_REC special target do not affect DO reuse. You can use the .MAKEFILES_AFFECT_REUSE target to enable recorded makefiles to affect DO reuse. (If you want to have some recorded makefiles affect reuse, but not all, you can also use the .DEPENDENCY_IGNORED_FOR_REUSE special target in conjunction with this target.)

Note: If a makefile is declared an explicit dependency of a target, it always affects DO reuse for that target, whether or not .MAKEFILES_AFFECT_REUSE was used.

Makefiles recorded in a configuration record are labeled by mklabel -config. Makefiles that were recorded in a configuration record but not recorded by using .MAKEFILES_AFFECT_REUSE are ignored by catcr -critical_only and diffcr -critical_only.

.MAKEFILES_IN_CONFIG_REC: file ...

You can use this special target to record the versions of makefiles in the configuration records of derived objects.

This target takes an optional dependency list, which might be a pattern. When used without a dependency list, this target causes all makefiles read by a build session to be recorded in the configuration record of all derived objects built during that build session.

To conserve disk space, you may want to supply a dependency list to this target so that, for example, only DOs built for top-level targets have the makefiles recorded in their configuration records.

.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_MATCH_SLINKS: tgt ...

When used, this target specifies that clearmake does not attempt to apply CR-based build-avoidance to a target file when it is a symbolic link, but uses time stamps, if applicable.

This special target takes one or more (white-space-separated) target path names. You can specify the path names with a %tail-matching pattern.

.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 and Linux) 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_SIBLING_DO_CONTAINED_IN : dir ...

This special target suppresses the creation of derived object for any file that lives in or beneath a specified directory. For example, if the makefile has the following targets:

.NO_SIBLING_DO_CONTAINED_IN: sun5/%  
objs/sun5/a.o: src/a.c    
cc -o $@ -c $<  

objs/sun5/subdir/a2.o: src/a2.c    
cc -o $@ -c $<  

objs/b.o: src/b.c    
cc  -o $@ -c $<  

then the written files named a.o and a2.o do not become DOs, but the file b.o does.

If a makefile contains the following:

.NO_SIBLING_DO_CONTAINED_IN: subdir%    

all: subdir1/T1 subdir2/T2  

subdir1/T1:          
touch $@          
touch $@.sibling  

subdir2/T2:        
touch $@        
touch $@.sibling

then subdir1/T1 and subdir2/T2 become derived objects, but subdir1/T1.sibling and subdir2/T2.sibling do not.

This target takes one or more (white space-separated) directory path names. You can specify the path names with a %tail-matching pattern.

.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 and Linux) 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 and Linux only

You can use the following target only in BOS files or makefiles on UNIX or Linux.

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

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 path names

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 path names in makefiles to guarantee the consistency of the resulting config records. Even if your MVFS is not case-preserving, use case-correct path names so that users on case-preserving computers can share the makefile.

MVFS settings and case requirements for makefiles describes makefile requirements for the different MVFS settings.

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 Linux and UNIX system command shells in makefiles

On Windows, clearmake accepts either slashes ( / ) or backslashes ( \) in path names. However, clearmake uses a backslash as the separator in any path names 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 path names 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 path names. 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.

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 or Linux:

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 or Linux:

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 or Linux:

BUILD_DATE :sh = date

On Windows:

NT_VER :sh = VER

Special targets

You can use some VersionVault 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 or Linux:

include /usr/local/lib/ux.optionss
include $(OPTS_DIR)/pm_build.options

On Windows:

include \lib\aux.options
sinclude $(OPTS_DIR)\pm_build.options

Comments

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