tests: More basic tests.

tests: Print PASS/FAIL for each test.

Simple test harness.

run: Improve consistency of error messages.

Make sure we always print the line number and the full name + params
of any goal or tactic which fails.

jobs: Wait for completion even in the error case.

Previously if we hit an error (last_exn being set) then we exited the
loop immediately and re-raised the exception.  However this means jobs
which are still running would continue to run after goals exited.
Move the wait code outside the loop to ensure we always wait for jobs
to complete even in the error case.

tests: Add basic tests.

Use 'make check' to run them.

parser: Allow an empty goal statement with no targets, deps or code.

This allows you to write "do nothing" goals like:

  goal all ;

build: Add 'make maintainer-clean' passthrough rule.

stdlib: Add wrap function.

stdlib: Don't add \n after quoted_string.

run: Add %goals_final_check variable when evaluating tactics.

This is true ("1") if this is the final check that the goal evaluation
was successful.  It allows tactics to behave differently when
evaluating if we need a rebuild vs checking that the rebuild was
successful.

Split implementation into dependency analysis and traversal.

utils: Add unique () function.

jobs: Don't let Failure exception escape from worker.

Also stop the wait () function if the stop flag is set so we don't
wait forever for jobs which are never going to be run.

cmdline: Make sure all errors go through main () function.

jobs: Introduce stop_all function to stop job submission on error.

Update TODO.

build: Create man/ subdirectory before building man pages.

Implement parallel jobs (-j option).

build: Remove man/*.? man pages when running 'make clean'.

Fixes commit abfde4ea239de6b9458243a862d5da0302a241a4.

docs: Add empty Goalfile(5) and goals-reference(5).

docs: Write man pages to man/ subdirectory.

Allows us to test multi-parameter goals.

docs: Expand the basic man page.

docs: Use pod2man -u option.

cmdline: Don't convert Goalfile, includes to absolute paths.

We actually want these to be relative to the -C directory,
same as make.

Add documentation subdirectory.

In debug mode (-d) print all shell scripts executed.

Add README file for the project.

Update TODO.

eval: Split running external code according to return type.

Previously we were wrongly hiding stdout in some cases.

Fixes commit a48b05d35f0646322e8178ff10f8ed7af3e739aa
and commit 2ac1b84cb49ad04e27b4543436b0227153fbfb15.

Implement pure functions.

lexer: Use @{...} for quiet code sections.

parser: Fix parsing of patterns containing explicit tactic names.

parser: Fix tracking of beginning of line for error messages.

Copy system environment into initial env, and also add %stdlib.

Allow functions "returning strings" (etc), redefine sort function.

Standardize running code in a single function, include prelude.sh.

Update TODO

Functions return expressions instead of only lists of strings.

build: Create dependencies for Goalfile itself.

stdlib: Implement sort function.

Update TODO.

build: Generate complete OCaml dependencies.

Because we didn't use -I src on the ocamldep command line, ocamldep
didn't generate the complete set of dependencies.

Ast: Standard location for ocamldoc comments.

stdlib: Implement wildcard function.

Implement functions.

Ast: Remove functions which were moved to Eval module.

Updates commit f36210fd16a8e4e4d6ecdd8825bf8b8307943472.

build: Add depend goal and 'make depend'.

build: Don't always pass -d to goals.

We can enable debugging on a case-by-case basis when necessary.

build: Fix construction of parser.mli

build: Fix ocamldep invocation.

build: Fix 'goals clean' rule.

stdlib: Fix *file tactic.

Broken test if there is more than one dependency.

run: Fix whitespace.

run: Better debugging and error messages for goals and tactics.

run: If multiple goals match a tactic, at most one must have a CODE section.

This now works the same way as make.

Don't default to echoing tactic command.

Update TODO

In dependency file, use ; between statements.

So this parses correctly.

parser: Optional semicolon between statements.

Simplify Constructor -> Ctor.

Rename Eval -> Run, split out some Ast functions into new Eval.

This gives us more consistent nomenclature:

  - "Run" for running targets.
  - "Eval" for simplifying and evaluating expressions, etc.
  - "Ast" is a library of AST-related structures.

eval: Don't check target was rebuilt if there is no code.

A pure dependency rule like:

  "foo.o": "foo.c"

doesn't contain any code, so it doesn't make sense to check if the
target has been rebuilt.

Use goals itself exclusively to build.

eval: Goals with no targets always need a rebuild.

eval: If multiple goals match a tactic, run them all.

lexer: Fix parsing of { characters in CODE sections.

eval: Explicit function to evaluate goal arguments.

Revert "eval: Expand goal args before running the goal."

This reverts commit 8509cad9b10205b7bec23eb59ba63e88c3d0fcb3.

eval: Expand goal args before running the goal.

Lexer: Allow "-" char in the middle of identifier names.

This allows eg maintainer-clean to be a goal name.

Ast: Rename ECallTactic to ETacticConstructor.

This is a constructor, it's not 'calling' anything.

Ast: Change EGoal -> EGoalDefn, ETactic -> ETacticDefn.

Implement -include (optional include) command.

Fix ‘goal’ when it appears as a target (meaning ‘goal()’).

More TODO ideas.

Add some more debugging.

Implement -d (debug) option.

Change -V to -v for compat with make.

stdlib: Add some rules for OCaml code.

Implement stdlib directory, -I, --no-prelude, etc.

Define OCaml Config module in ./configure, ./run script, --version option.

Implement tactics.

Remove Ast.PVar.

Pure variables as patterns are disallowed.  Patterns have a distinct
type from expressions so allowing an expression to be substituted
causes complications.  In particular we want to know statically how
many targets a goal has, which is not possible if a variable can be
substituted here.

You can still write:

  "%name": ...

Run code with set -e / set -x.

Actually run goal code.

Add implicit tactic rebuild.

We don't need to look for a goal covering every tactic, if the tactic
doesn't need rebuilding.

Substitute %<, %@ etc variables into code.

Add Ast.to_shell_script.

Previously we were confusing Ast.substitute with the place where we
need to shell quote.

Hard code *file tactic.

Implement tactic matching.

todo: Note default parameters.

Factor out param_decl and improvements to AST printing.

Refactor evaluation.

Also more work on pattern matching and when to rebuild.

Fix file() -> *file() in comment about tactics.

Updates commit b14ff66c953e6a73e9ac2fe8d42dd68e92e58f53.

Rename Ast.StringMap -> Ast.Env

Begin converting Ast print functions so they can be used with format %a.

Send debug message to stderr.

Print errors (Failure exceptions) nicely.

Define *file() syntax for tactic constructors.

Alternative syntaxes considered where ~file and &file.

Attach parser location information to AST nodes.