Holmake: boldify announcements of starting to work in directories

Reduce and prettify Holmake's recursive invocation verbiage

Add directory field to dep. graph nodes

This is a first, easy, step towards having Holmake work over multiple
directories at once.

Holmake improvements (bug in caching of dep. analysis; diag change)

Two intertwined patches (bad form I know):
1. Fix the bug in tests/indepchildren.
2. Revise the internal diag function to take a function generating a
string rather than a string; then the work of generating the string
only happens if diagnostics have been asked for.

Move holmake-recursion code into Holmake.sml

The move of this code into separate Holmake_tools.sml happened in
order to try to share code between MoscowML and PolyML
implementations. I imagined then that I would have to have the
top-level functions trapped in language-specific implementations, but
that various leaf-level things could be reused. I noticed that the
recursion logic governing the way INCLUDES specs were followed could
be stripped out of Holmake and so moved maybe_recurse into
Holmake_tools.

But now, the much more sensible scheme whereby only specific leaves in
the code-tree are language specific is used, and so the quite
high-level recursion stuff can come back into Holmake.sml.

Do "last made by" checks even when cleaning in Holmake

This reverts 550b90aca, which doesn't come with enough justification
for me to understand the problem that I thought I was solving in 2010.
The problem with omitting the checks is that if the "wrong" Holmake is
called, and if the Holmakefile contains references to things like
$(HOLDIR), then the wrong cleaning action can occur.

For example, if an INCLUDES line refers to $(HOLDIR), then a recursive
clean will recurse into the wrong directory. Similarly, if an
EXTRA_CLEANS line refers to $(HOLDIR), then the wrong file will get
deleted.

Fix Holmake bug to do with --no_prereqs

Bug is identified in previous commit (and in accompanying test-cases).
It comes down to the fact that even with --no_prereqs specified,
Holmake needs to scan ancestor directories in order to get
dependencies correctly recorded in generated files, particularly
Theory.uo files.

Update Holmake to cope with Theory.dat files

No tests specific to that feature yet.

Still also need to update for Moscow ML.

Fix a bug in generation of dependencies for Holmake "side products"

Slightly extend test-cases

Allow an indication of side-products of theory builds

Basically, write something like

foo: *theorynameScript.sml

to indicate that foo will be built when the theory theoryname is
built. As part of the process, provide much better testing of the
parallel execution of multiple target rules and completely change the
way these are handled.

In particular, the dependency graph that Holmake maintains now does
not have multiple targets for a single node, but instead makes sure
that when a command is executed for a single target, all nodes that
would execute the same command are considered to be running at the
same time, and get the same success/failure status when the command
finishes.

Needs documentation, but is progress with Github issue #429

Fix Holmake's -I flag so it is not applied recursively

The -I flag to Holmake was being re-interpreted with each recursive
entry of a fresh directory, so that when the included directory was
entered, the Holmake process then attempted to again include that path
in the newly entered directory. This is fine if the path is
absolute (the loop detection will stop the recursion), but if it's
relative, the path won't be present in that directory and a
file-system IO error occurs.

Closes #413

Remove an unused binding in Holmake.sml

Allow c/line switches to appear after "real" arguments in Holmake

Thanks to Magnus for the suggestion.

Rebuild .uo and .ui files without forcing unnecessary extra work

This is by analogy with what has already been attempted for heaps, and
is progress with github issue #105.

Also fix a bug with the heap handling if the heap was in a
directory with script-files (not the case with the heaps in HOL/src):
the dependency graph built for the directory spotted that there was a
dependency from the heap to the script files, and even though the
heap's time-stamp was set appropriately, the existence of the link in
the graph meant that the rest of the graph got executed.

The fix for this (in both the case of the heap and the .uo/.ui file)
is for execution of graph nodes to check at the time the node is made
ready to execute if the target really does need to be redone (by
examining time-stamps). Then, the rebuild can be skipped even though
the initial analysis thought it was going to have to happen.

Future work:
- For the moment, both build and Holmake rely on having a particular
environment variable set to enable this option. I will augment
and/or replace this with command-line options. (The buildheap
program needs to retain this use of the environment variable though
because neither Holmake nor build control how that program is
called; instead this program is called by the user via
Holmakefiles.)
- Build needs to take an option to clean a HOL installation of its
heaps and ui/uo files. I don't know how to automatically identify
the heaps, but could just purge those that are identified as such in
Holmakefiles.

Get Holmake to build targets with no deps again

Closes #348

Patch glitch in Holmake output.

The "usepfx" flag is no longer set when `CLINE_OPTIONS = -j1` appears in the Holmakefile. It will only be set when `-j1` is in the actual command line.

This avoids lines that is too long (due to `Holmake: ` being printed) when recursing into a directory that doesn't have `CLINE_OPTIONS = -j1` in it's Holmakefile.

I suspect `Holmake: ` is not printing when recursing into a directory that does have `CLINE_OPTIONS = -j1`, but this wouldn't result in lines that are too long.

Handle opentheory intermediate leftovers better

In particular, the parallel process for building .art files creates an
intermediate thyname.artScript.sml file that shouldn't be regarded as a
normal script file. (Indeed, it can't work as a normal script file
because of the presence of the full-stop in the theory name, so there's
a warning emitted for other occurrences of this if seen.)

These intermediates can be cleaned by Holmake as well if they're
found. (Normal execution of Holmake will remove these files after
they're used, but if the build is interrupted for some reason, they get
left behind.)

Ensure Holmakefiles' CLINE_OPTIONS are always read

When a recursive Holmake call happens in another directory, that
directory's Holmakefile's CLINE_OPTIONS need to get a chance to affect
the behaviour of Holmake in that directory.

Improve error-reporting in -j1 Holmake

Includes more error messages when --dbg is set

Remove unused arg to Holmake introduced in b59cee6

I mistakenly thought it was going to be necessary to know if the Holmake
function was being called for the first time or not.

Provide CLINE_OPTIONS variable in Holmakefiles

This variable is read for a set of default command-line switches which
are treated as if they are being passed on the command-line. Things
actually passed on the command-line are applied after what is in the
Holmakefile, possibly overriding the file's switches. Of course, the
command-line can also change the defaults with both of the
--no_hmakefile and --holmakefile=file switches.

Motivated by the desire to have Holmakefiles be able to contain good -j
options for specific directories.

This pretty well supercedes the OPTIONS variable, so the documentation
in DESCRIPTION has been adjusted accordingly.

Closes #86

Clean out .hollogs at the same time as .HOLMK.

Fix Holmake's recursive clean

Includes a test-case.

Closes #338

Make multibuild output prettier

Enable multiplexed builds for Poly/ML

Output is horrendous at the moment

Make dep. graph store single commands per node

This is something of a reversal of 8f7f1c9; but there I was worried
about smashing multiple commands into a single string, which is clearly
still a bad thing to have happen. The problem with having multiple
commands in a single node is that a multiplexing implementation has to
execute them as an atomic block, which I don't like.

Get Holmake to check for circular dependency loops

This check was briefly removed as I switched to the 'create dependency
graph; perform builds' implementation.

Now also with a regression test.

Make Holmake less chatty by default

Enable old level of chattiness with -v or --verbose command line option.

Replace 'print' with Holmake's output functions

Re-enable rebuild_deps behaviour in Holmake

Fix Holmake under Poly/ML

Two significant changes required:
* the dependency graph now records nodes for files that already exist
and don't need rebuilding. The graph marks such nodes as Succeeded.
This gives nodes that depend on these files extra things to point to,
giving them a more complete picture. This change also simplifies the
code for building the dependency graph in the first place, but is
possibly redundant given the second change...
* Before "compiling" a source-file, the Poly/ML implementation runs the
Holdep analysis on that source file in order to get a better picture
of its dependencies stored in the corresponding .uo or .ui file. This
is necessary, because the preliminary dependency analysis may be done
before the source file even exists. (E.g., fooTheory.sig may not exist
when Holmake first starts work in a directory.)

Get "build from graph" Holmake to compile

Poly/ML version fails miserably at boolScript hurdle however.

Start to implement building from dependency graph

This code is as yet unconnected to any execution, and is attempting to
replicate the behaviour that we have at the moment (corresponding to
what will eventually be -j 1).

Slightly adjust some types along the way, including changing a
bool*bool*string tuple into a record that identifies what the bools are.

Make dep graph record file-name in dependency link

Nodes in the graph are commands that may build multiple targets at once.
Nonetheless, other nodes may only depend on one of those targets, so we
can record this on the arc from the target to the dependency.

Make dep-graphs store commands as lists of strings

This will make it easier to extract and act on leading indicators such
as @ and - on each line. If a line is

-command

then it could be passed to the shell as command ; true. If the command
has the leading @, then that line shouldn't be echoed to the shell. In
a parallelised context, I'm not sure that anything much should be echoed
to the user anyway.

Previously, I had Holmake concatenate the lines from the Holmakefile
with intervening semicolons, which would just make extracting the @ and
- characters that much harder.

Add unused API to build targets from dep. graph

Tweak Holmake's usage message

Fix dep-graph's handling of rules with >1 target

Now such rules (including the implicit/built-in rule that builds
<n>Theory.sig and <n>Theory.sml from one invocation of a script file),
only generate one node in the dependency graph.

Actually, the code will treat

foo: deps
command

bar: deps
command

as if they were written

foo bar: deps
command

because the former is what the latter expands into.

Implement a -n option for Holmake

This uses the new dependency graph technology. It doesn't look
particularly pretty at the moment, but

Holmake -n -q

should be useful. (The -q suppresses useless info about automatic
dependency analysis.)

Closes #283

Make KERNELID var get its proper value in Holmake

Issue was that Poly/ML evaluates many things at compile time rather than
run-time.

Remove diffs between poly and mosml Holmake impls

Next step is to actually remove as much as possible of the
tools-poly/Holmake directory.

Pass more info to the impl-specific BuildCommand

In particular, pass
- the full Holmakefile-derived envlist function (which turns $(...)
references into string lists);
- output functions (warn, die, etc)
- quit_on_failure, which is derived from the Holmakefile and core
command-line options

Delete bogus comments in both Holmake.sml files

Move impl-specific exn stuff to separate files

Interrupt is Interrupt in mosml, but SML90.Interrupt in Poly/ML code
mentioning it should be factored out.

Put a main around mosml's Holmake

This makes the Moscow ML version look more like the Poly/ML version.

Push poly and mosml Holmakes closer together

Move mosml Interrupt magic to mosml directory

Remove very stale copyright notice on Holmake src

Purge Holmake.sml of much Moscow ML specific code

The Moscow ML stuff has moved into mosml/BuildCommand etc

Progress with github issue #77

Cleanup more Holmake code

This is in pursuit of more unification between Moscow ML and Poly/ML
implementations (github issue #77).

Purge some unused c/line options for Holmake

Unused in the sense that I don't think anyone ever used them and
supporting them was just making the code base unnecessarily complicated.

Switch Moscow ML Holmake to GetOpt cline options

This is a precursor to merging more of the Poly/ML and Moscow ML
implementations, as per github issue #77

Systeml's mk_xable returns status, not string

It previously used to return the string of the executable version of the
file. On Windows, this makes sense because making things executable
consists of adding the string ".exe", changing the filename. But we
already have the xable_string function for doing this calculation.

Make Holmake follow INCLUDES recursively, even when given PHONY target

Closes #145

More progress with Holmake and recursive dependencies

Both depchain selftests pass now on both Poly and Moscow ML.

The treatment of relative and absolute directories is more careful,
for which see the hmdir structure within Holmake_tools. This stuff is
really only as complicated as it is for cosmetic reasons: the various
messages printed to the user try to avoid absolute paths for as long
as possible. However, more/most/all internal uses will now be with
absolute paths, which should help.

Remove unnecessary print_list function within Holmake.sml

Fix recursive dep problem under Moscow ML (re-enable regression test)

Build commands within Holmake are now passed the correct include
information.

Most of a fix for recursive holdep problem.

See test-case in Holmake/tests/depchain1

Test-case still not re-enabled as I don't think this quite works for
Moscow ML yet.

Some incidental progress with sharing more code between Moscow ML and
Poly/ML (github issue #77).

Slightly adjust Holmake's internal interface.

Just a refactoring to make the recursive calls return a record-option
rather a straight set. Intention is to next make the return value a
bigger record so that it can return a list of extra includes, thereby
allowing a fix for issue illustrated by the holdep test-case under
Holmake/tests.

runholdep function moves to Holmake_tools (Poly/ML Holmake affected)

In the latter module, it can be used in the Poly/ML implementation.
This is progress with github issue #77

The Poly/ML implementation now fails the regression test in

tools/Holmake/tests/depchain1/dir3

so comment out that test from the build sequence temporarily. I
believe there will be a Holmake failure in machine-code until the
behaviour is properly fixed. I hope selftest 2 will go through
correctly.

Holmake's output also changes slightly because I've been more
consistent about using the built-in 'info' function instead of print.

Do away with use of mosmllex and mosmlyac in Holdep.

These tools are too Moscow ML specific, and unnecessary given that we
have mllex available for all SML implementations.

Isolate writing of Holdep info into file from calculation of info

Start to rationalise Holdep's interface.

There were some strange holdovers still in there from the ancient days
when it was a separate command-line tool. Aim is to ultimately drop
Lexer.lex and Parser.grm and replace those with the Holdep_tokens
lexer. I'm also only doing this to the Moscow ML implementation for
the moment with the ultimate aim being to have the Poly and mosml
implementations using the same Holdep code.

Move generate_all_plausible_targets into common Holmake_tools.

Progress with #77

Share more code between mosml and poly Holmake.

Work on github issue #77

Implement recursive cleaning for Holmake.

Closes #125; not extensively tested.

Fix a bug in mosml Holmake's handling of SIGOBJs including spaces.

Problem was that the patsubst function was applied and would result in
a command line that looked like

-I first-part-of-path -I second-part-of-path

Copy tweak made by fd4c62c8 to Poly/ML Holmake in Moscow ML version.

Get recursive Holmake to handle absolute paths in INCLUDES.

This was broken by 44cef4623, handling #64.

Improve Holmake's messages about recursive invocation.

Closes #64.

Also helps with #77 because the code controlling the recursive
invocations is now in Holmake_tools rather than in both versions of
Holmake.sml.

Get mosml Holmake to build with new Holmake_types.

Move more code (including directory cleaning) into common Holmake_tools.

Move Holmake's structured file type into shared Holmake_tools module.

Use Basis 2002's isSuffix function rather than write my own.

Allow Moscow ML build to happen using (as yet unreleased) v2.10.

Basic strategy is to make adoption of basis 2002 even more
thorough. In particular, the Timer structure is now as per
the 2002 Basis.

It is possible to detect that one is working with Moscow ML 2.10 or
later by checking the Holmakefile variable $(HAVE_BASIS2002), which is
set (to value "1") when in 2.10 or later. It is unset elsewhere. See
an example of its use in help/src-sml/Holmakefile.

Holmake shouldn't do 'last-made-by' check when cleaning.

Make Holmake use a 'ignore failure' delete in another place.

This seemed to be tripping up a recent Windows build of mine. Perhaps
because it was trying to delete the Script executable while the
file-system still thought it was being run. I couldn't get the same
error on my virtual machine version of Windows though.

Holmake warns about (and doesn't use) an INCLUDES dir that doesn't exist.

More diagnostics when the debug flag is passed to Holmake.

New Holmake feature: check to see if it should be being used as builder.

If, as I do, you have multiple HOL installations on the same machine,
it can be a pain to remember to build things with the correct Holmake.
On the other hand, it's certainly convenient having a Holmake in one's
PATH. So, this change gets Holmake to determine if it should be the
Holmake being used, and if it thinks another Holmake should be being
used instead, that other Holmake gets called out to instead. This
"calling out" is done through Systeml.exec, so can even be across
Poly/ML-mosml boundaries.

There are two ways in which a Holmake can decide determine the correct
Holmake to be used. If it sees a .HOLMK/lastmaker file containing a
path, then this is used. This file is written to when a Holmake does
decide it's the rightful make executable. Secondly, if Holmake
determines (by jumping up through the file-system) that it is being
called inside a HOL installation already containing a bin/Holmake,
then that is taken to be correct.

When a second Holmake is called as part of this process, it also gets
passed the --nolmbc flag ("no last made by check") to stop it going
through the whole process all over again.

Allow Holmakefiles to specify building of files outside the current directory.

Fix error in definition of HOLMOSMLC-C makefile variable.

Augment base Holmake environment with ML_SYSNAME, MLLEX and MLYACC.

Also move code implementing this into shared Holmake_types module.

Fix Holmake's handling of 'remote' targets that don't exist.

Old behaviour didn't complain about targets not in the current directory if
they didn't exist.

Added a missing space that prevented the basis2002 being used for compilation, when an "INCLUDES= ???" statement was present in the Holmakefile.

New "portable" subdirs per ML implementations in src/portableML.

Hope to do away with Poly/ML specific code in tools-poly eventually,
moving it into src/portableML/poly. tools/build-sequence now records
that the implementation-specific directories have to be included.

The Moscow ML Holmake was not recording the dependency on basis2002.uo
correctly. Now that it does, the attempt to do it explicitly in
src/portableML/Holmakefile can be dropped.

Make the basis hack for Moscow ML correctly identify which version of
the Basis Library we are trying to emulate.

More corrections required to our sources when I do the migration to
Basis 97 properly.

Start to implement the Basis 97 extensions that Moscow ML hasn't got
in order to force our codebase to get up-to-date. It should also
mean less bodging around for the Poly/ML code. I haven't checked that
my changes to tools-poly/poly/poly-init2.ML have done all that is
required yet. Feel free to fix problems arising there (I hope it will
just be a matter of deleting things).

Add yet more diagnosis information for Holmake failures.

Attempt to get better diagnostics out of a failing make_up_to_date
function. In particular, Poly/ML seems to occasionally cause this
(now altered) handler to fire.

Fix a bug whereby the calculation of dependencies was ignoring
PRE_INCLUDES.

Changes to the way Holmake attempts to call it recursively. It should
no longer call itself more than once in the same directory.

Document existence of polyml port in the release notes, and also in
the process of documenting recursive Holmake and the --no_prereqs
option, add a feature to Holmake allowing NO_PREREQS to be an OPTION
as well. Document the latter in the Description (also add some \index
entries there).

(We are going to have to merge the Holmake implementations if at all
possible; having to update two versions is a pain.)

Implement an idea of Magnus's. Holmake will now recursively attempt
to make directories that are indicated as dependencies via -I flags or
INCLUDES variables. This behaviour can be prevented via the
--no_prereqs toggle on the command-line. The core system seems to
build OK, but there may be some horrific consequence I've overlooked,
so please test.

* Changed Systeml to make it more compatible with the Basis Library,
in particular, by using OS.Process rather than just Process, which
is a MoscowML invention dating back to the times when it couldn't do
nested structures
* This has knock-on effects in a surprising number of places because
Moscow ML doesn't know that OS.Process.status is the same type as
Process.status.
* Also invent a PreProcess structure just to store isSuccess which is
in the most recent Basis, but not Moscow ML.

Rework lexing of Holmakefiles so that the system doesn't choke on
Joe's monster example. The result is simpler code (which is a bit
worrying in itself), and one less dependency on mosmllex. It
successfully reads all of the distribution's makefiles, as well as
Joe's.

Attempt to fix occasional bad behaviour of Holmake when unquoting files
(most recently observed by Thomas). I'm not sure even this solution is
perfect. Dealing with Interrupt by pretending it is a synchronous exception
is almost certainly dubious, for all that it works "most of the time".

Fix a problem identified by Tom Ridge with the --rebuild_deps flag to
Holmake. Now the behaviour of this flag is to just call Holmake cleanDeps
before proceeding with the rest of its build.

Stop Holmake's default behaviour (i.e., what you get if you just type
Holmake) from trying to make files that start with "."
This can still be forced by actually putting such files in the command-line.

Last change I want to make before releasing; change the MOSMLDIR value
to be the directory containing the mosml binaries, rather than being
the parent of this directory. This should make life easier on those
installations where the mosml install doesn't look like
mosml
+----- bin
+----- lib
(Some do not have bin and lib as siblings. The code using MOSMLDIR
never looks for anything except bin underneath it.)

Mention the --logging option in the usage output.

Drop the colon from the time-stamps; this causes grief on Windows.

Make holmake actually pay attention to the --logging flag, rather than
just logging invariably.

Update build and Holmake to store theory-build time information in time-
stamped files. Also modify export_theory to support this. This should
help us get some numbers on the effectiveness or otherwise of changes
to the kernel. Document the new option to Holmake in the DESCRIPTION.

Fix for the bug that saw file-names with spaces recorded in bogus fashion
in .HOLMK .d files. Now, spaces there are escaped with back-slashes.

Implement and document a new option flag for Holmakefiles, to make it easier
to automatically apply the --qof flag.

Fix a very minor bug so that Holmake doesn't say "nothing to be done for
foo" immediately after having done a slew of stuff to build foo.

Keith pointed out that we probably wanted binary copy under Windows, and
that you got this with the /b flag.

Provide a method for moving and copying files from within Holmake that is
OS-independent. Will document in DESCRIPTION on Monday, but I'm going home.

Fix for a problem Konrad identified with the way that Holmake was protecting
its built-in variables (MOSMLCOMP etc). Now Holmake doesn't protect
variables that may be used in situations where they are concatenated
with others, but does protect those that will be used on their own (such
as MOSMLC etc).
This requires the provision of a protect function in make-files, so
this is documented in the DESCRIPTION. I think things should be right,
but please check that this works, particularly anyone on Windows!

Change to winNT systeml so that "protect" isn't so protective. What
works for Unix doesn't seem to usually work for Windows.

Tweak to automatic dependency analysis: when about to call Holdep, pass
in not only those targets explicitly mentioned in any Holmakefile, but
also those files that we know how to make from these using the standard
implicit rules. These files are then allowed to appear as dependencies
when Holdep calculates them.

Failing a catastrophic bug, this should be my last Holmake check-in for a
while. This fixes the behaviour when a Holmakefile contains multiple
rules for the same target. If there is more than one rule with
accompanying commands, then the later rule takes precedence and earlier
command-accompanied rules are ignored. However, it is always OK to have
rules that specify just dependencies. These dependencies are merged together
and added to the last command-accompanied rule, if there is one, or
are merged together and left as they are (without commands).

Edging ever closer to a complete re-implementation of GNU make with
HOL-shaped knobs on. :-) Added subst and if built-in function. I
actually need the former for my C stuff (believe it or not).
Still to do: handle multiple instances of the same target correctly.

Changes in diagnostics, and tidying up of this code. GNU make mimicry
taken to ridiculous lengths.

More GNU make mimicry: - and @ characters can be duplicated endlessly at
the start of a makefile's command-line (multiple instances are idempotent).

Some code reorganisation, plus:
* if there is a "clean" target in the Holmakefile, then this takes priority
over the native "clean" functionality.
* fixed a bug in the treatment of the initial - and @ characters on
command-lines within a Makefile. (Caused in turn by the decision to
support HOLMOSMLC and friends as variables, even in the absence of
enclosing $(...) syntax.)

If no_sigobj is called for, either on the command-line or within a
Holmakefile, then make this cause no_overlay as well.

Previously, I had a slightly ugly hack in place to stop failing theories
attempting to build twice: I claimed that Theory.sig files depended on
Theory.sml files (i.e., that to build one of the former, you needed to
just one of the latter). This was a bit of a perversion of the truth,
and I now have a better way of dealing with things. So, my code needs
to change. I thought I'd made the appropriate change, but it failed.
Looking at my code, I couldn't see how it should work, nor how the
even older, pre-hack, code worked. So, here's another fix.

Close a directory stream.

Fairly drastic change to the way in which Holmake interprets Holmakefiles.
These can now contain arbitrary variable definitions and references, just
like in normal make-files. Rules can also use have multiple targets, and
the special variables $< and $@ have the appropriate meaning. These are
Feature Requests 597666 and 597668. I will attempt to document the changes
more thoroughly in the DESCRIPTION.

Fixes so that Holmake looks at bin/quote-filter.exe on w2k, instead
of bin/quote-filter.

Can now use $(VARNAME) references anywhere inside a Holmakefile. At the
moment, may only refer to two known variables HOLDIR and SIGOBJ, but the
intention is to allow users to define their own variables. This is useful
for constructing rules that depend on the mkword executable, which lives
within the source tree, and for referring to theories that live in
SIGOBJ.

Removed long-standing silliness that saw Holmake blessed with its own
version number.

Modified Holmake to support a -i (or --interactive) command-line flag.
(This is feature request #611879.) Modified documentation to reflect this
and slightly updated some other things in the Description that caught my
eye.

Fix bootstrapping bug: Holmake should use unquote on every file *only
if unquote exists*. Otherwise, it should cross its fingers and hope.

Oops!

Revisions to make the documentation and the behaviour conform. I think
the behaviour is now clear.

Slight functionality update, making the behaviour emulate what I see
(GNU) make do when the user calls for a file to be made, that file is
present, but there is nothing in the Makefile to say what to do with
that file.
Also wrote a comment to clarify something that was confusing me a
great deal.

Fixed a long-standing bug that would occasionally cause Holmake to try
to build a failing theory twice. It didn't entirely realise that a
failed attempt to build fooTheory.sig meant that an attempt to build
fooTheory.sml would also fail. Now this is treated by encoding an
explicit dependency of fooTheory.sig on fooTheory.sml. This makes the
algorithm try to build fooTheory.sig by first building fooTheory.sml, and
if this succeeds, it does nothing, because it's happy that having the latter
means having the former.
This scheme fixes the observed bug, but isn't quite right: if you delete
a Theory.sig file but keep the Theory.sml file in place, Holmake won't
rebuild them both. I'm thinking about how to fix this, but it doesn't
seem a likely error. Nor is it hard to work around: simply delete the
Theory.sml file.

When Holmake is run without any command-line arguments, it scans the
directory to look for likely targets to build, and also checks the
Holmakefile if any. This means that the order in which targets are
attempted used to be done in a way that was dependent on the local
file-system's internal directory structure. Now, the list is sorted, which
should ensure reproducible behaviour.

Fairly radical change. Now all of the "build-time" constants (such as
HOLDIR, MOSMLDIR and things like that) have been moved into the Systeml
file that is built and compiled as practically the first thing that
configure.sml does. This change means that we don't need to specially
generate Holmake.sml, Globals.sml, makebase.sml or build.sml. All of
these files can now just refer to Systeml. (In order to bring this
about for build.sml, I've also shifted the SRCDIRs variable to build.sml.
It had been in configure.sml just so that it could be copied into build.)