Product Requirements Document for Minor Scheme.

See 'design' for overall project goals.  This PRD is intended to
provide measurable guideposts leading toward those goals.  The idea is
to be (approximately) as detailed as a contractual partner would be in
specifying the various stages of completion.  This is somewhat
similar to, even overlapping with, the Tactics section in 'design',
and it may be helpful at some point to unify the duplicated material.

Throughout this document, the hypothetical contractual partner is
referred to as "The Big Kahuna", sometimes shortened to "Kahuna".

-------------------------------------------------------------------------

Check off ("[X]") each step as it is completed.  Intermediate steps
for well-defined, separable tasks may be inserted at any time.

[X]  Define Minor Scheme's portability.
     List the exact characteristics of a system that can build and run
     Minor Scheme.

     [Done, see "Minor requires" in 'design'.]

[X]  Test the system thoroughly in 'configure'.
     If The Big Kahuna runs

       $ ./config.sh && ./configure && make

     in a working copy, he expects to get either all currently
     available Minor Scheme executable targets, or comprehensible
     error messages explaining exactly what aspect(s) of his system
     prevented the build from succeeding.  Kahuna does not require
     that the error list be complete: he is happy to see just the
     first detected insufficiency, then see the next one only after
     the first is rectified, and so on.

[X]  Implement those C interfaces from include/minor/minor.h that do
     not require eval, environment, or full numeric tower support.

     There will be test programs in gc/tests to exercise all
     implemented functions.

[X]  Define the Core Scheme language.

     Core Scheme is the language to be yielded by macro expansion, and
     to be implemented by both the interpreter and the compiler.

     A file defining the language will be added to the 'doc' directory.

[X]  Define the interpreter's intermediate representation.

     The interpreter compiles Core Scheme to an intermediate
     representation called "icode".

     A file defining the representation, and explaining how it is to
     be used, will be added to the 'doc' directory.

[ ]  Implement Core Scheme.

     Write a Core Scheme->icode compiler, and an icode interpreter, in C.

     There will be a test program in gc/tests that reads Core Scheme
     expressions from a file and evaluates them, and test scripts that
     use it and check the results.

[ ]  Macro expander.

     Implement hygenic macros and MzScheme modules in Scheme (refer to
     MzScheme spec).

     There will be test scripts in gc/tests that define macros and
     modules, and verify that they are expanded properly.

[ ]  Full R5RS, with MzScheme macros and modules

     This will not include bignum support, but it will detect
     overflows.

     There will be test scripts in gc/tests that verify Minor's
     ability to run R5RS programs.

-------------------------------------------------------------------------

This will bring Minor Scheme to the point where procedures to generate
native-code can be implemented in Scheme, followed by an assembler,
etc.  The Big Kahuna sees far, but says nothing now, concentrating
instead on the tasks at hand.