Changes since 2.1

    LOCATE_TARGET now has a new flavor, LOCATE_SOURCE that is used for
    generated source files (by yacc and lex).

    The 'if' statement now compares all elements in expressions;
    previously, it only compared the first element of each list.

    Header file includes now happen in the proper order.  The limit
    of 10 include files has been eliminated.

    The Jambase is now compiled into jam, and so no longer needs
    installing.  The plain Jambase can still be referenced explicitly 
    with -f.

    The syntax "if $(A) in $(B)" is now supported.  It is true of all
    elements of $(A) can be found in $(B), _or_ if $(A) is empty.

    $(FOO:S) now refers to the _last_ suffix if a filename has more than
    one dot (.) in it.

    Variables local to the current context may be declared at the top
    of a block (just after a {) with "local var ... ;"

    Rules may be invoked with more than just targets and sources, i.e.
    there may be more than one : in a rule invocation.  These parameters 
    are called $(1), $(2), $(3), etc, and $(<) and $(>) are synonymous 
    with $(1) and $(2).  Actions can still only take two sets parameters,
    i.e. $(<) and $(>).

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

    The NT command executor now handles multiple line actions, by sending
    the actions one line at time to the DOS shell.

    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.

    Variables whose values are targets can be expanded to the bounded target
    names in action blocks.  Previously, only $(<) and $(>) referred to bounded
    targets.  With new syntax "actions Rulename bind var..." the named variables
    will be expanded in the action block.

    Jam now by default builds itself into a platform specific subdirectory.

    Due to internal restructuring of the Jambase, the old "Install" rule
    is no longer available.  Use InstallBin, InstallFile, InstallLib,
    InstallMan, or InstallShell instead.

    If a command line is longer than MAXCMD (which is OS dependent),
    jam now issues an error and exits rather than dumping core.

    Interactive UNIX (ISC) supported, thanks to Matthew Newhook.

    Targets are universally lowercased on NT and VMS.  Great minds think
    alike.  (NT courtesy of Matthew Newhook.)

    Concurrent process support is somewhat enabled for NT.

    'actions updated' now includes sources in $(>) that are newer than
    their parents in the dependency graph.  Previously, only sources
    that were actually updated in that run were included in the expansion
    of $(>) for 'actions updated'.  If a source was created in a first
    invocation of jam (or manually), then in a second run the new source
    would imply updating the target, but that source wouldn't appear in
    $(>) for 'actions updated'.  Now any source that causes the target
    to be updated shows up in $(>) for 'actions updated'.

    New HDRGRIST variable in Jambase to allow for headers with the same
    name to be distinguished.

    New JAMDATE variable initialized to be `ctime()` for simple date
    stamping.

    The debugging levels were moved a little (again): -d3 now includes binding
    and timestamp information for all targets, so that that single level
    reports the work of make0().  -d4 now just dumps memory statistics.
    The whole story is:

	-d1 - trace actions
	-d2 - dump actions, trace quiet actions
	-d3 - trace dependency analysis
	-d4 - show shell arguments
	-d5 - trace jamfile compilation
	-d6 - show directory/header file/archive scans
	-d7 - show variable settings
	-d8 - show variable fetches
	-d9 - show variable manipulation, scanner tokens

    The debugging flag -d has been changed again.  Now any -d turns off the
    default (-d1): -dx turns on all levels up to x; -d+x turns on level x.
    So -d0 turns off everything and -d2 _just_ shows command text.

    Fixed a few holes in the path handling on NT: it 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 "\".

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

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

	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.
