Release notes for Jam/MR 2.2
(formerly Jam - make(1) redux)
1. Release info:
Jam/MR 2.2
October 22, 1997
VERSION 2.2
PATCHLEVEL 1
1.1 Bug fixes since 2.2 patchlevel 0
The NT handle leak in execunix.c has been fixed, thanks to
Gurusamy Sarathy. (Patchlevel 1).
2. Compatibility
Jam/MR 2.2 is a roll-up of 'Jam - make(1) redux' release 2.1+.
Most of the changes described below were available before this,
in the jam.2.1.plus.tar ball.
The Jam/MR 2.2 language is a superset of the 2.1 language;
Jamfiles, Jambase, and other rulesets used in 2.1 can be used
with the 2.2 language support.
See 'Jambase Changes', below, to see if your Jamfiles need any
changes to work with the 2.2 Jambase.
3. Changes Since 2.1
New product name: Jam/MR. (Executable program is still named 'jam'.)
Documentation rewritten; HTML versions supplied.
3.1 Changes to Jam/MR Language (See Jamlang.html)
Rules may now have more fields than just $(<) and $(>).
Local variables are now supported.
The expression 'if $(A) in $(B)' is now supported.
New variable modifiers :U and :L result in uppercased or lowercased
values.
New variable modifier :P reliably results in parent directory
of either a file or directory. (Previously, :D was used, but on VMS
:D of a directory name is just the directory name.)
The :S variable modifier now results in the _last_ suffix if a
filename has more than one dot (.) in it.
New predefined $(JAMDATE) variable is initialized at runtime for
simple date stamping.
New predefined variables $(OSVER) and $(OSPLAT) are used to
distinguish among operating system versions and hardware platforms,
when possible.
New 'bind' qualifier on action definitions allows variables
other than $(<) and $(>) to be bound with SEARCH and LOCATE paths.
Action buffer size is no longer limited by MAXCMD. Instead, each
line in an action is limited by MAXLINE, defined for each OS, and
the entire action size is limited by CMDBUF.
3.2 Jambase Changes (See Jamfile.html)
Jambase has been reworked to incorporate new language features.
A handful of new utility rules has been added: makeString,
makeDirName, etc.
New HDRGRIST variable in Jambase allows for headers with the same
name to be distinguished.
LOCATE_TARGET now has a new flavor, LOCATE_SOURCE, that is used by
rules that generate source files (e.g., Yacc and Lex).
Header file includes now happen in the proper order. The limit of
10 include files has been eliminated.
The old "Install" rule is no longer available. Use InstallBin,
InstallFile, InstallLib, InstallMan, or InstallShell instead.
3.3 'jam' Changes (See Jam.html)
'jam' can now be built as a stand-alone program, with Jambase
compiled into the executable. An external or alternate Jambase can
still be referenced explicitly with -f.
On command failure, 'jam' now emits the text of the command that
failed. This is a compromise between the normal -d1 behavior (where
commands were never seen) and -d2 (where commands are always seen).
'jam' now exits non-zero if it doesn't have a total success. A parse
error, sources that can't be found, and targets that can't be built
all generate non-zero exit status.
The debugging levels (-d flags) have been slightly redefined.
The supplied Jamfile now builds 'jam' into a platform specific
subdirectory. This lets you use the same source directory to
build 'jam' for more than one platform.
The supplied Jamfile does not rebuild generated source files by
default. (They are supplied with the distribution.) See Jamfile
for more information.
4. Fixed Bugs
The 'include' bug has finally been fixed, so that include
statements take effect exactly when they are executed,
rather than after the current statement block. This also
corrects the problem where an 'include' within an 'if'
block would wind up including the file one token after the
'if' block's closing brace. Credit goes to Thomas Woods
for suggesting that the parse tree generation and parse
tree execution be paired in their own loop, rather than
having the parser execute the tree directly.
The setting and extracting of grist has been regularized:
normally, if you set a component of a filename (using the
:DBSMG= modifiers), you are supposed to include the delimiters
that set off the component: that is, you say "$(x:S=.suffix)",
including the ".". But with grist it was inconsistent
between setting and getting: setting grist required no
<>'s, while getting grist included them. Getting grist
continues to return the <>'s, but now setting grist can
either include them (the new way) or not (the old way).
'actions together' now suppresses duplicate sources from
showing up in $(>).
Accessing variables whose names contained ['s (as happens with
MkDir on VMS) wasn't working, because it treated the [ as an
array subscript. Now [ and ] are, like :, handled specially so
that they can appear in variable values.
The 'if' statement now compares all elements in expressions;
previously, it only compared the first element of each list.
If a command line in an action is longer than MAXLINE (formerly
MAXCMD), 'jam' now issues an error and exits rather than dumping
core.
If a Jamfile ended without a trailing newline, jam dumped core.
This has been fixed.
5. Porting
See jam.h for the definitive list of supported platforms.
Since 2.1, support has been added for:
Macintosh MPW
Alpha VMS
Alpha NT
NT PowerPC
BeOS
MVS OE
UNIXWARE
QNX
SINIX (Nixdorf)
OS/2
Interactive UNIX (ISC), courtesy of Matthew Newhook
5.1 NT Support Fixes
The NT command executor now handles multiple line actions, by writing
multi-line actions to a batch file and executing that.
Targets are universally lowercased on NT. (Matthew Newhook)
Concurrent process support is fully enabled for NT.
(Gurusamy Sarathy <gsar@engin.umich.edu>)
Path handling: Jam/MR now knows that the directory component of "D:\"
is "D:\", just as on unix it knows that the directory component of
"/" is "/". It also now successfully gets the timestamp for "D:\"
or just plain "\".
5.2 VMS Support Fixes
VMS support is much, much better now. The path name manipulation
routines (in pathvms.c) were more or less rewritten, and they now
handle the vagaries of combining directory and file names properly.
Targets are universally lowercased on VMS.
Multi-line command blocks on VMS are now executed in a single system()
call rather than separate ones for each line, so that actions can
be DCL scripts.
Release notes for Jam 2.1.
1. Release info:
Jam 2.1
February 1, 1996
VERSION 2.1
PATCHLEVEL 0
2. Porting
Linux is now supported.
FREEBSD is now supported.
SCO ("M_XENIX") now supported.
NCR now supported.
NEXT support from karthy@dannug.dk (Karsten Thygesen)
DECC support from zinser@axp614.gsi.de (Martin P.J. Zinser)
I have changes for OS/2, but no way to test them. Volunteers?
I have VMS multiprocess support, but no way to test it. Volunteers?
2.1. NT Support fixes.
The NT support is considerably more real than it was in 2.0.
Filent.c had its syntax error corrected, it no longer skips the
first entry when scanning directories, and it handles string
tables in archives (for long object file names).
The Jambase was changed a bit to support the various C/C++
compilers on NT, although it has only been thorougly tested
with MSVC20.
You still need to set MSVCNT or BCCROOT to the root of the
the compiler's directory tree, and you'll get an error if you
don't set it (rather than getting a pile of mysterious errors).
2.2. Other porting fixes.
SPLITPATH now set up for UNIX (:), NT (;), VMS (,)
Jambase support for Solaris works better now: the location of
AR is hardwired to /usr/ccs/bin/ar and it knowns "install"
doesn't take -c. Solaris -- how the mighty have fallen.
To handle Linux's wacko yacc, jamgram.h is now included after
scan.h so that YYSTYPE is define.
3. Jambase Changes (see Jamfile.html)
SubDir now computes the root directory for the source tree, if
the variable naming the root directory isn't set in the environment.
It counts the number of directory elements leading from the root
to the current directory (as passed to SubDir) and uses that many
"../"'s to identify the root. This means that to use SubDir you
no longer have to have anything special set in the environment.
InstallFile is now an alias for InstallLib.
'first' is now dependency of all pseudo-targets (all, files,
exe, lib, shell), so that jamming any of these pseudo-targets
also builds any dependencies of 'first'.
The File rule definition in the Jambase was missing an &.
The File rule now calls the Clean rule, so that installed files
get cleaned.
4. Jam changes (see Jam.html)
Variables may now be set on the command line with -svar=value.
Targets marked with NOUPDATE are now immune to the -a (anyhow)
flag. Previously, the MkDir rule would try to recreate directories
that already exist when jam was invoked with -a.
A new variable, $(JAMVERSION), joins the small list of built-in
variables. It it set to the release of jam, currently "2.1".
If an actions fails, jam now deletes the target(s). It won't
delete libraries or other targets that are composites. This is
now consistent with jam's behavior on interrupts (it deletes the
targets).
Jam had a nasty bug when setting multiple variables to the same
value: if the first two variable names were the same, the variable
value got trashed. This also affected "on target" variables if
the first two targets were the same. For example:
FOO on bar.c bar.c foo.c = a b c ;
This would mangle the value of FOO for bar.c and foo.c. This has
been fixed.
Jam would generate bogus numbers when reporting the number of
targets updated after an interrupt. It now is more careful about
counting.
The debugging flag -d has been extended. In addition to supporting
-dx (turn on debugging for all levels up to x) there is also now
-d+x (turn on debugging at only level x). The default output
level is -d1 (-or d2 if -n is given); this can be turned off with
-d0. The debug levels are listed in jam.1 and jam.h.
The parsing debug output now uses indenting to indicate when
one rule invokes another.
Release notes for Jam 2.0.
1. Release info:
Jam 2.0
March 10, 1994
VERSION 2.0
PATCHLEVEL 5
2. Porting
Windows/NT is now (crudely) supported, courtesy of Brett Taylor
and Laura Wingerd.
COHERENT/386 is now supported, courtesy of Fred Smith.
Solaris archive string table for long archive names is now
supported, thanks to Mike Matrigali.
3. Compatibility
Jam 2.0 syntax is a superset of Jam 1.0 syntax, and thus it can
interpret a Jam 1.0 Jambase.
The Jam 2.0 Jambase is a superset of the Jam 1.0 Jambase, and
thus it can include a Jamfile written for Jam 1.0.
4. Changes from Jam 1.0 to Jam 2.0
4.1. Documentation changes
New Jamfile.5 manual page, with lots of examples and easy
reading. It replaces both the old "Examples" file as well as
the old Jambase.5 manual page.
jam.1 edited by Stephen W. Liddle and Diane Holt.
4.2. Jambase Changes (see Jamfile.5)
4.2.1. New rules:
There are new rules to make handling subdirectories easier:
SubDir, SubInclude, SubDirCcFlags, SubDirHdrs.
There are new rules to handle file-specific CCFLAGS and HDRS:
ObjectCcFlags and ObjectHdrs.
Misc new rules: HardLink, InstallShell, MkDir.
New rule "clean" that deletes exactly what jam has built, and
"uninstall" that deletes exactly what was installed.
New rules for handling suffixes .s, .f, .cc, .cpp, .C.
4.2.2. Old rules:
The InstallBin, Lib, Man, and the new Shell rules now take the
destination directory as the target and the files to be copied
as sources. These rules formerly took the files to be copied
as targets, and used built-in destination directories of
$(BINDIR), $(LIBDIR), $(MANDIR), and $(BINDIR).
The InstallBin, Lib, Man, and Shell rules use the install(1)
program now, instead of doing their own copying.
The Cc rule now uses -o when possible, rather than moving the
result. Some platforms (Pyramid?) have a broken -o.
Jambase rules taking libraries, objects, and executables now
all ignore the suffixes provided and use the one defined in the
Jambase for the platform.
Stupid yyacc support moved out of Jambase, as jam is its only
likely user.
Jambase now purturbs library sources with a "grist" of
SOURCE_GRIST.
4.2.3. Misc:
The names of the default rules defined in Jambase have been
lowercased and un-abbreviated, to be more imake(1) like.
The Jambase has been reorganized and sorted, with VMS and NT
support moved in from their own files.
The Jambase has been relocated on UNIX from /usr/local/lib/jam
to /usr/local/lib.
4.3. Jam changes (see jam.1)
4.3.1. Flags:
New -a (anyhow) flag: means build everything.
New -j<x> flag: run jobs in parallel.
Old -t now rebuilds the touched target, rather that just the
target's parents.
-n now implies -d2, so that you see what's happening. The
debug level can be subsequently overridden.
New -v to dump version.
4.3.2. Rules:
New ALWAYS rule behaves like -t: always builds target.
New EXIT rule makes it possible to raise a fatal error.
New LEAVES rule which say target depends only on the update
times of the leaf sources.
New NOUPDATE rule says built targets only if they don't exist.
NOTIME has been renamed NOTFILE, to more accurately reflect its
meaning (it says a target is not to be bound to a file).
4.3.3. Variables:
New special variable JAMSHELL: argv template for command execution
shell.
Variables, both normal and target-specific, can have their
value appended with the syntax "var += value" or "var on target
+= value".
"?=" is now synonymous with "default =".
Imported enviroment variable values are now split at blanks
(:'s if the variable name ends in PATH), so that they become
proper list values.
4.3.4. Misc:
Files to be sourced with "include" are now bound first, so
$(SEARCH) and $(LOCATE) affect them. They still can't be
built, though.
New modifier on "actions": "existing" causes $(>) to expand
only those files that currently exist.
4.3.5. Bug fixes:
When scanning tokens known to be argument lists (such as the
arguments to rule invocations and variable assignment), the
parser now tells the scanner to ignore alphabetic keywords, as
all such lists terminate with punctuation keywords (like : or
;). This way, alphabetic keywords don't need to be quoted when
they appear as arguments.
The scanner has been fixed to handle oversized tokens,
unterminated quotes, unterminated action blocks, and tokens
abutting EOF (i.e. a token with no white space before EOF).
The progress report "...on xth target..." used to count all
targets, rather than just those with updating actions. Since
the original pronouncement of targets to be udpated included
only those with updating actions, the progress report has been
changed to match.
'If' conditionals now must be single arguments. Previously,
they could be zero or more arguments, which didn't make much
sense, and made things like 'foo == bar' true. The comparison
operator is '=', and '==' just looked like the second of three
arguments in the unary "non-empty argument list" conditional.
Header files indirectly including themselves were mistakenly
reported as being dependent on themselves. Recursing through
header file dependencies is now done after determining the fate
of the target.
The variable expansion support was expanding $(X)$(UNDEF) as if
it were $(X). It now expands to an empty list, like it
should.
The UNIX version of file_build() didn't handle "dir/.suffix"
right. Now it does.
The VMS command buffer was assumed to be as large as 1024 bytes,
which isn't the case everywhere as it is related to some weird
quota. It has been lowered to 256.
$(>) and $(<) wouldn't expand in action blocks if the targets
were marked with NOTIME. Now they expand properly.
Malloc() return values are now checked.
The variable expansion routine var_expand() is now a little
faster, by taking a few often needed shortcuts.
The VMS version of file_build() used the wrong length when
re-rooting file names that already had directory compoents.
This was fixed.
Various tracing adjustments were made.
5. Limitations/Known Bugs
The new Windows/NT support has only been marginally tested. It
is dependent on certain variables being set depending on which
compiler you are using. You'll need to look in the file
Jambase and see what variables are expected to be set.
The VMS support has been tested, courtesy of the DEC guest
machine, but has not been hammered fully in release 2.0. It
was used quite a bit in Jam 1.0.
Jam clean when there is nothing to clean claims it is updating
a target.
Because the include statement works by pushing a new file in
the input stream of the scanner rather than recursively
invoking the parser on the new file, multiple include
statements in a rule's procedure causes the files to be
included in reverse order.
If the include statement appears inside an if block, the
parser's attempt to find the else will cause the text of the
included file to appear after the first token following the
statement block. This is rarely what is intended.
In a rule's actions, only $(<) and $(>) refer to the bound file
names: all other variable references get the unbound names.
This is a pain for $(NEEDLIBS), because it means that library
path can't be bound using $(SEARCH) and $(LOCATE).
With the -j flag, errors from failed commands can get
staggeringly mixed up. Also, because targets tend to get built
in a quickest-first ordering, dependency information must be
quite exact. Finally, beware of parallelizing commands that
drop fixed-named files into the current directory, like yacc(1)
does.
A poorly set $(JAMSHELL) is likely to result in silent
failure.