// runtime.js: the main runtime library for whalesong.
//

if(this['plt'] === undefined) { this['plt'] = {}; }


// All of the values here are namespaced under "plt.runtime".
(function(scope) {
    var runtime = {};
    scope['runtime'] = runtime;



    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    // We try to isolate the effect of external modules: all the identifiers we
    // pull from external modules should be listed here, and should otherwise not
    // show up outside this section!
    var isNumber = plt.baselib.numbers.isNumber;
    var isNatural = plt.baselib.numbers.isNatural;
    var isReal = plt.baselib.numbers.isReal;
    var isPair = plt.baselib.lists.isPair;
    var isList = plt.baselib.lists.isList;
    var isVector = plt.baselib.vectors.isVector;
    var isString = plt.baselib.strings.isString;
    var isSymbol = plt.baselib.symbols.isSymbol;
    var isNonNegativeReal = plt.baselib.numbers.isNonNegativeReal;
    var equals = plt.baselib.equality.equals;

    var NULL = plt.baselib.lists.EMPTY;
    var VOID = plt.baselib.constants.VOID_VALUE;
    var EOF = plt.baselib.constants.EOF_VALUE;

    var NEGATIVE_ZERO = plt.baselib.numbers.negative_zero;
    var INF = plt.baselib.numbers.inf;
    var NEGATIVE_INF = plt.baselib.numbers.negative_inf;
    var NAN = plt.baselib.numbers.nan;

    var makeFloat = plt.baselib.numbers.makeFloat;
    var makeRational = plt.baselib.numbers.makeRational;
    var makeBignum = plt.baselib.numbers.makeBignum;
    var makeComplex = plt.baselib.numbers.makeComplex;

    var makeSymbol = plt.baselib.symbols.makeSymbol;

    var makeBox = plt.baselib.boxes.makeBox;
    var isBox = plt.baselib.boxes.isBox;

    var makeVector = plt.baselib.vectors.makeVector;
    var makeList = plt.baselib.lists.makeList;
    var makePair = plt.baselib.lists.makePair;


    var Closure = plt.baselib.functions.Closure;
    var finalizeClosureCall = plt.baselib.functions.finalizeClosureCall;
    var makePrimitiveProcedure = plt.baselib.functions.makePrimitiveProcedure;


    // Other helpers
    var withArguments = plt.baselib.withArguments;
    var heir = plt.baselib.heir;
    var makeClassPredicate = plt.baselib.makeClassPredicate;
    var toDomNode = plt.baselib.format.toDomNode;
    var toWrittenString = plt.baselib.format.toWrittenString;
    var toDisplayedString = plt.baselib.format.toDisplayedString;



    // Frame structures.
    var Frame = plt.baselib.frames.Frame;
    var CallFrame = plt.baselib.frames.CallFrame;
    var PromptFrame = plt.baselib.frames.PromptFrame;

    // Module structure
    var ModuleRecord = plt.baselib.modules.ModuleRecord;



    // Ports
    var OutputPort = plt.baselib.ports.OutputPort;
    var isOutputPort = plt.baselib.ports.isOutputPort;
    var StandardOutputPort = plt.baselib.ports.StandardOutputPort;
    var StandardErrorPort = plt.baselib.ports.StandardErrorPort;
    var OutputStringPort = plt.baselib.ports.OutputStringPort;
    var isOutputStringPort = plt.baselib.ports.isOutputStringPort;




    // Exceptions and error handling.
    var raise = plt.baselib.exceptions.raise;
    var raiseUnboundToplevelError = plt.baselib.exceptions.raiseUnboundToplevelError;
    var raiseArgumentTypeError = plt.baselib.exceptions.raiseArgumentTypeError;
    var raiseContextExpectedValuesError = plt.baselib.exceptions.raiseContextExpectedValuesError;
    var raiseArityMismatchError = plt.baselib.exceptions.raiseArityMismatchError;
    var raiseOperatorApplicationError = plt.baselib.exceptions.raiseOperatorApplicationError;
    var raiseOperatorIsNotPrimitiveProcedure = plt.baselib.exceptions.raiseOperatorIsNotPrimitiveProcedure;
    var raiseOperatorIsNotClosure = plt.baselib.exceptions.raiseOperatorIsNotClosure;
    var raiseUnimplementedPrimitiveError = plt.baselib.exceptions.raiseUnimplementedPrimitiveError;




    

    var testArgument = plt.baselib.check.testArgument;
    var testArity = plt.baselib.check.testArity;
    var makeCheckArgumentType = plt.baselib.check.makeCheckArgumentType;

    var checkOutputPort = plt.baselib.check.checkOutputPort;
    var checkString = plt.baselib.check.checkString;
    var checkSymbol = plt.baselib.check.checkSymbol;
    var checkProcedure = plt.baselib.check.checkProcedure;
    var checkNumber = plt.baselib.check.checkNumber;
    var checkReal = plt.baselib.check.checkReal;
    var checkNonNegativeReal = plt.baselib.check.checkNonNegativeReal;
    var checkNatural = plt.baselib.check.checkNatural;
    var checkInteger = plt.baselib.check.checkInteger;
    var checkRational = plt.baselib.check.checkRational;
    var checkPair = plt.baselib.check.checkPair;
    var checkList = plt.baselib.check.checkList;
    var checkVector = plt.baselib.check.checkVector;
    var checkBox = plt.baselib.check.checkBox;
    var checkMutableBox = plt.baselib.check.checkMutableBox;
    var checkInspector = plt.baselib.check.checkInspector;



    //////////////////////////////////////////////////////////////////////]
    // The MACHINE


    // This value will be dynamically determined.
    // See findStackLimit later in this file.
    var STACK_LIMIT_ESTIMATE = 100;


    var Machine = function() {
	this.callsBeforeTrampoline = STACK_LIMIT_ESTIMATE;
	this.val = undefined;
	this.proc = undefined;
	this.argcount = undefined;
	this.env = [];
	this.control = [];     // Arrayof (U Frame CallFrame PromptFrame)
	this.running = false;
	this.modules = {};     // String -> ModuleRecord
        this.mainModules = []; // Arrayof String
	this.params = {

	    // currentDisplayer: DomNode -> Void
	    // currentDisplayer is responsible for displaying to the browser.
	    'currentDisplayer': function(MACHINE, domNode) {
		$(domNode).appendTo(document.body);
	    },
	    
	    // currentErrorDisplayer: DomNode -> Void
	    // currentErrorDisplayer is responsible for displaying errors to the browser.
	    'currentErrorDisplayer': function(MACHINE, domNode) {
                $(domNode).appendTo(document.body);
	    },

            'currentInspector': plt.baselib.inspectors.DEFAULT_INSPECTOR,
	    
	    'currentOutputPort': new StandardOutputPort(),
	    'currentErrorPort': new StandardErrorPort(),
	    'currentSuccessHandler': function(MACHINE) {},
	    'currentErrorHandler': function(MACHINE, exn) {
                MACHINE.params.currentErrorDisplayer(
                    MACHINE,
                    toDomNode(exn));
            },
	    
	    'currentNamespace': {},
	    
	    // These parameters control how often
	    // control yields back to the browser
	    // for response.  The implementation is a
	    // simple PID controller.
	    //
	    // To tune this, adjust desiredYieldsPerSecond.
	    // Do no touch numBouncesBeforeYield or
	    // maxNumBouncesBeforeYield, because those
	    // are adjusted automatically by the
	    // recomputeMaxNumBouncesBeforeYield
	    // procedure.
	    'desiredYieldsPerSecond': 5,
	    'numBouncesBeforeYield': 2000,   // self-adjusting
	    'maxNumBouncesBeforeYield': 2000, // self-adjusting

	    'currentPrint': defaultCurrentPrint


	};
	this.primitives = Primitives;
    };




    // Approximately find the stack limit.
    // This function assumes, on average, five variables or
    // temporaries per stack frame.
    // This will never report a number greater than MAXIMUM_CAP.
    var findStackLimit = function(after) {
	var MAXIMUM_CAP = 100000;
	var n = 1;
	var limitDiscovered = false;
	setTimeout(
	    function() {
		if(! limitDiscovered) {
		    limitDiscovered = true;
		    after(n);
		}
	    },
	    0);
	var loop1 = function(x, y, z, w, k) {
	    // Ensure termination, just in case JavaScript ever
	    // does eliminate stack limits.
	    if (n >= MAXIMUM_CAP) { return; }
	    n++;
	    return 1 + loop2(y, z, w, k, x);
	};
	var loop2 = function(x, y, z, w, k) {
	    n++;
	    return 1 + loop1(y, z, w, k, x);
	};
	try {
	    var dontCare = 1 + loop1(2, "seven", [1], {number: 8}, 2);
	} catch (e) {
	    // ignore exceptions.
	}
	if (! limitDiscovered) { 
	    limitDiscovered = true;
	    after(n);
	}
    };


    // Schedule a stack limit estimation.  If it fails, no harm, no
    // foul (hopefully!)
    setTimeout(function() {
	findStackLimit(function(v) {
	    // Trying to be a little conservative.
	    STACK_LIMIT_ESTIMATE = Math.floor(v / 10);
	});
    },
	       0);


    // captureControl implements the continuation-capturing part of
    // call/cc.  It grabs the control frames up to (but not including) the
    // prompt tagged by the given tag.
    var captureControl = function(MACHINE, skip, tag) {
	var i;
	for (i = MACHINE.control.length - 1 - skip; i >= 0; i--) {
	    if (MACHINE.control[i].tag === tag) {
		return MACHINE.control.slice(i + 1,
					     MACHINE.control.length - skip);
	    }
	} 
	raise(MACHINE, new Error("captureControl: unable to find tag " + tag));
    };



    // restoreControl clears the control stack (up to, but not including the
    // prompt tagged by tag), and then appends the rest of the control frames.
    // At the moment, the rest of the control frames is assumed to be in the 
    // top of the environment.
    var restoreControl = function(MACHINE, tag) {
	var i;
	for (i = MACHINE.control.length - 1; i >= 0; i--) {
	    if (MACHINE.control[i].tag === tag) {
		MACHINE.control = 
		    MACHINE.control.slice(0, i+1).concat(
			MACHINE.env[MACHINE.env.length - 1]);
		return;
	    }
	}
	raise(MACHINE, new Error("restoreControl: unable to find tag " + tag));     

    };


    // Splices the list argument in the environment.  Adjusts MACHINE.argcount
    // appropriately.
    var spliceListIntoStack = function(MACHINE, depth) {
	var lst = MACHINE.env[MACHINE.env.length - 1 - depth];
	var vals = [];
	while(lst !== NULL) {
	    vals.push(lst.first);
	    lst = lst.rest;
	}
	vals.reverse();
	MACHINE.env.splice.apply(MACHINE.env,
				 [MACHINE.env.length - 1 - depth, 1].concat(vals));
	MACHINE.argcount = MACHINE.argcount + vals.length - 1;
    };


    // Unsplices a list from the MACHINE stack.
    var unspliceRestFromStack = function(MACHINE, depth, length) {
	var lst = NULL;
	var i;
	for (i = 0; i < length; i++) {
	    lst = makePair(MACHINE.env[MACHINE.env.length - depth - length + i], 
                           lst);
	}
	MACHINE.env.splice(MACHINE.env.length - depth - length,
			   length, 
			   lst);
	MACHINE.argcount = MACHINE.argcount - length + 1;
    };



    // recomputeGas: state number -> number
    var recomputeMaxNumBouncesBeforeYield = function(MACHINE, observedDelay) {
	// We'd like to see a delay of DESIRED_DELAY_BETWEEN_BOUNCES so
	// that we get MACHINE.params.desiredYieldsPerSecond bounces per
	// second.
	var DESIRED_DELAY_BETWEEN_BOUNCES = 
	    (1000 / MACHINE.params.desiredYieldsPerSecond);
	var ALPHA = 256;
	var delta = (ALPHA * ((DESIRED_DELAY_BETWEEN_BOUNCES -
			       observedDelay) / 
			      DESIRED_DELAY_BETWEEN_BOUNCES));
	MACHINE.params.maxNumBouncesBeforeYield = 
            Math.max(MACHINE.params.maxNumBouncesBeforeYield + delta,
                     1);
    };


    var HaltError = function(onHalt) {
        // onHalt: MACHINE -> void
        this.onHalt = onHalt || function(MACHINE) {};
    };


    var Pause = function(onPause) {
        // onPause: MACHINE -> void
        this.onPause = onPause || function(MACHINE) {};
    };

    var PAUSE = function(onPause) {
        throw(new Pause(onPause));
    };
    



    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    // The toplevel trampoline.
    //
    //
    // trampoline: MACHINE (MACHINE -> void) -> void
    //
    // All evaluation in Racketland happens in the context of this
    // trampoline.
    //
    var trampoline = function(MACHINE, initialJump) {
	var thunk = initialJump;
	var startTime = (new Date()).valueOf();
	MACHINE.callsBeforeTrampoline = STACK_LIMIT_ESTIMATE;
	MACHINE.params.numBouncesBeforeYield = 
	    MACHINE.params.maxNumBouncesBeforeYield;
	MACHINE.running = true;

	while(true) {
            try {
		thunk(MACHINE);
		break;
            } catch (e) {
                // There are a few kinds of things that can get thrown
                // during racket evaluation:
                //
                // functions: this gets thrown if the Racket code
                // realizes that the number of bounces has grown too
                // large.  The thrown function represents a restarter
                // function.  The running flag remains true.
                //
                // Pause: causes the machine evaluation to pause, with
                // the expectation that it will restart momentarily.
                // The running flag on the machine will remain true.
                //
                // HaltError: causes evaluation to immediately halt.
                // We schedule the onHalt function of the HaltError to
                // call afterwards.  The running flag on the machine
                // is set to false.
                //
                // Everything else: otherwise, we send the exception value
                // to the current error handler and exit.
                // The running flag is set to false.
		if (typeof(e) === 'function') {
                    thunk = e;
                    MACHINE.callsBeforeTrampoline = STACK_LIMIT_ESTIMATE;

		    if (MACHINE.params.numBouncesBeforeYield-- < 0) {
			recomputeMaxNumBouncesBeforeYield(
			    MACHINE,
			    (new Date()).valueOf() - startTime);
			setTimeout(
			    function() { trampoline(MACHINE, thunk); },
			    0);
			return;
		    } else {
                        continue;
                    }
		} else if (e instanceof Pause) {
                    var restart = function(thunk) {
		        setTimeout(
			    function() { trampoline(MACHINE, thunk); },
			    0);
                    };
                    e.onPause(restart);
                    return;
                } else if (e instanceof HaltError) {
		    MACHINE.running = false;
                    e.onHalt(MACHINE);
                    return;
                } else {
		    MACHINE.running = false;
                    MACHINE.params.currentErrorHandler(MACHINE, e);
	            return;
		}
            }
	}
	MACHINE.running = false;
        setTimeout(
            function() { MACHINE.params.currentSuccessHandler(MACHINE); },
            0);
	return;
    };



    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////







    var defaultCurrentPrint = new Closure(
	function(MACHINE) {
            if(--MACHINE.callsBeforeTrampoline < 0) { 
                throw arguments.callee; 
            }
	    var elt = MACHINE.env[MACHINE.env.length - 1];
	    var outputPort = 
		MACHINE.params.currentOutputPort;
	    if (elt !== VOID) {
		outputPort.writeDomNode(MACHINE, toDomNode(elt, 'print'));
		outputPort.writeDomNode(MACHINE, toDomNode("\n", 'display'));
	    }
            return finalizeClosureCall(MACHINE, VOID);
	},
	1,
	[],
	"printer");





    var VariableReference = function(prefix, pos) {
        this.prefix = prefix;
        this.pos = pos;
    };



    // A continuation prompt tag labels a prompt frame.
    var ContinuationPromptTag = function(name) {
	this.name = name;
    };



    // There is a single, distinguished default continuation prompt tag
    // that's used to wrap around toplevel prompts.
    var DEFAULT_CONTINUATION_PROMPT_TAG = 
	new ContinuationPromptTag("default-continuation-prompt-tag");







    

    // Primitives are the set of primitive values.  Not all primitives
    // are coded here; several of them (including call/cc) are injected by
    // the bootstrapping code in compiler/boostrapped-primitives.rkt
    var Primitives = {};

    var installPrimitiveProcedure = function(name, arity, f) {
        Primitives[name] = f;
        Primitives[name].arity = arity;
        Primitives[name].displayName = name;
    };

    var installPrimitiveClosure = function(name, arity, f) {
        Primitives[name] = 
            new Closure(f, arity, [], name);
    };


    var installPrimitiveConstant = function(name, v) {
        Primitives[name] = v;
    };



    installPrimitiveConstant('pi', plt.baselib.numbers.pi);
    installPrimitiveConstant('e', plt.baselib.numbers.e);
    installPrimitiveConstant('null', NULL);


    installPrimitiveProcedure(
        'display', makeList(1, 2),
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    var outputPort = MACHINE.params.currentOutputPort;
	    if (MACHINE.argcount === 2) {
	        outputPort = checkOutputPort(MACHINE, 'display', 1);
	    }
	    outputPort.writeDomNode(MACHINE, toDomNode(firstArg, 'display'));
            return VOID;
        });

    installPrimitiveProcedure(
        'newline', makeList(0, 1),
        function(MACHINE) {
	    var outputPort = MACHINE.params.currentOutputPort;
	    if (MACHINE.argcount === 1) { 
	        outputPort = checkOutputPort(MACHINE, 'newline', 1);
	    }
	    outputPort.writeDomNode(MACHINE, toDomNode("\n", 'display'));
            return VOID;
        });

    installPrimitiveProcedure(
        'displayln',
        makeList(1, 2),
        function(MACHINE){
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    var outputPort = MACHINE.params.currentOutputPort;
	    if (MACHINE.argcount === 2) {
                outputPort = checkOutputPort(MACHINE, 'displayln', 1);
	    }
	    outputPort.writeDomNode(MACHINE, toDomNode(firstArg, 'display'));
	    outputPort.writeDomNode(MACHINE, toDomNode("\n", 'display'));
            return VOID;
        });



    installPrimitiveProcedure(
        'format',
        plt.baselib.arity.makeArityAtLeast(1),
        function(MACHINE) {
            var args = [], i, formatString;
            formatString = checkString(MACHINE, 'format', 0).toString();
            for(i = 1; i < MACHINE.argcount; i++) {
                args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
            }
            return plt.baselib.format.format(formatString, args, 'format');
        });


    installPrimitiveProcedure(
        'printf',
        plt.baselib.arity.makeArityAtLeast(1),
        function(MACHINE) {
            var args = [], i, formatString, result, outputPort;
            formatString = checkString(MACHINE, 'printf', 0).toString();
            for(i = 1; i < MACHINE.argcount; i++) {
                args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
            }
            result = plt.baselib.format.format(formatString, args, 'format');
            outputPort = MACHINE.params.currentOutputPort;            
	    outputPort.writeDomNode(MACHINE, toDomNode(result, 'display'));
            return VOID;
        });


    installPrimitiveProcedure(
        'fprintf',
        plt.baselib.arity.makeArityAtLeast(2),
        function(MACHINE) {
            var args = [], i, formatString, outputPort, result;
            outputPort = checkOutputPort(MACHINE, 'fprintf', 0);
            formatString = checkString(MACHINE, 'fprintf', 1).toString();
            for(i = 2; i < MACHINE.argcount; i++) {
                args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
            }
            result = plt.baselib.format.format(formatString, args, 'format');
	    outputPort.writeDomNode(MACHINE, toDomNode(result, 'display'));
            return VOID;
        });






    installPrimitiveProcedure(
        'current-print',
        makeList(0, 1),
        function(MACHINE) {
            if (MACHINE.argcount === 1) {
                MACHINE.params['currentPrint'] =                 
                    checkProcedure(MACHINE, 'current-print', 0);
                return VOID;
            } else {
	        return MACHINE.params['currentPrint'];
            }
        });


    installPrimitiveProcedure(
        'current-output-port',
        makeList(0, 1),
        function(MACHINE) {
            if (MACHINE.argcount === 1) {
                MACHINE.params['currentOutputPort'] = 
                    checkOutputPort(MACHINE, 'current-output-port', 0);
                return VOID;
            } else {
	        return MACHINE.params['currentOutputPort'];
            }
        });





    installPrimitiveProcedure(
        '=',
        plt.baselib.arity.makeArityAtLeast(2),
        function(MACHINE) {
	    var firstArg = checkNumber(MACHINE, '=', 0), secondArg;
	    for (var i = 1; i < MACHINE.argcount; i++) {
                var secondArg = checkNumber(MACHINE, '=', i);
	        if (! (plt.baselib.numbers.equals(firstArg, secondArg))) {
		    return false; 
	        }
	    }
	    return true;
        });


    
    installPrimitiveProcedure(
        '=~',
        3,
        function(MACHINE) {
	    var x = checkReal(MACHINE, '=~', 0);
	    var y = checkReal(MACHINE, '=~', 1);
	    var range = checkNonNegativeReal(MACHINE, '=~', 2);
            return plt.baselib.numbers.lessThanOrEqual(
                plt.baselib.numbers.abs(plt.baselib.numbers.subtract(x, y)), 
                range);
        });



    var makeChainingBinop = function(predicate, name) {
        return function(MACHINE) {
	    var firstArg = checkNumber(MACHINE, name, 0), secondArg;
	    for (var i = 1; i < MACHINE.argcount; i++) {
	        secondArg = checkNumber(MACHINE, name, i);
	        if (! (predicate(firstArg, secondArg))) {
		    return false; 
	        }
                firstArg = secondArg;
	    }
	    return true;
        };
    };

    installPrimitiveProcedure(
        '<',
        plt.baselib.arity.makeArityAtLeast(2),
        makeChainingBinop(plt.baselib.numbers.lessThan, '<'));


    installPrimitiveProcedure(
        '>',
        plt.baselib.arity.makeArityAtLeast(2),
        makeChainingBinop(plt.baselib.numbers.greaterThan, '>'));


    installPrimitiveProcedure(
        '<=',
        plt.baselib.arity.makeArityAtLeast(2),
        makeChainingBinop(plt.baselib.numbers.lessThanOrEqual, '<='));


    installPrimitiveProcedure(
        '>=',
        plt.baselib.arity.makeArityAtLeast(2),
        makeChainingBinop(plt.baselib.numbers.greaterThanOrEqual, '>='));
    

    installPrimitiveProcedure(
        '+',
        plt.baselib.arity.makeArityAtLeast(0),
        function(MACHINE) {
	    var result = 0;
	    var i = 0;
	    for (i = 0; i < MACHINE.argcount; i++) {
	        result = plt.baselib.numbers.add(
                    result, 
                    checkNumber(MACHINE, '+', i));
	    };
	    return result;
        });
    

    installPrimitiveProcedure(
        '*',
        plt.baselib.arity.makeArityAtLeast(0),
        function(MACHINE) {
	    var result = 1;
	    var i = 0;
	    for (i=0; i < MACHINE.argcount; i++) {
	        result = plt.baselib.numbers.multiply(
                    result, 
                    checkNumber(MACHINE, '*', i));
	    }
	    return result;
        });

    installPrimitiveProcedure(
        '-',
        plt.baselib.arity.makeArityAtLeast(1),
        function(MACHINE) {
	    if (MACHINE.argcount === 1) { 
	        return plt.baselib.numbers.subtract(
                    0, 
                    checkNumber(MACHINE, '-', 0));
	    }
	    var result = checkNumber(MACHINE, '-', 0);
	    for (var i = 1; i < MACHINE.argcount; i++) {
	        result = plt.baselib.numbers.subtract(
                    result, 
                    checkNumber(MACHINE, '-', i));
	    }
	    return result;
        });
    
    installPrimitiveProcedure(
        '/',
        plt.baselib.arity.makeArityAtLeast(1),
        function(MACHINE) {
	    var result = checkNumber(MACHINE, '/', 0);
	    for (var i = 1; i < MACHINE.argcount; i++) {
	        result = plt.baselib.numbers.divide(
                    result,
                    checkNumber(MACHINE, '/', i));
	    }
	    return result;
        });
    

    installPrimitiveProcedure(
        'add1',
        1,
        function(MACHINE) {
	    var firstArg = checkNumber(MACHINE, 'add1', 0);
	    return plt.baselib.numbers.add(firstArg, 1);
        });


    installPrimitiveProcedure(
        'sub1',
        1,
        function(MACHINE) {
	    var firstArg = checkNumber(MACHINE, 'sub1', 0);
	    return plt.baselib.numbers.subtract(firstArg, 1);
        });


    installPrimitiveProcedure(
        'zero?',
        1,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    return plt.baselib.numbers.equals(firstArg, 0);
        });


    installPrimitiveProcedure(
        'cons',
        2,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    var secondArg = MACHINE.env[MACHINE.env.length-2];
	    return makePair(firstArg, secondArg);
        });


    installPrimitiveProcedure(
        'list',
        plt.baselib.arity.makeArityAtLeast(0),
        function(MACHINE) {
	    var result = NULL;
	    for (var i = 0; i < MACHINE.argcount; i++) {
	        result = makePair(MACHINE.env[MACHINE.env.length - (MACHINE.argcount - i)],
		                  result);
	    }
	    return result;
        });

    installPrimitiveProcedure(
        'car',
        1,
        function(MACHINE) {
	    var firstArg = checkPair(MACHINE, 'car', 0);
	    return firstArg.first;
        });

    installPrimitiveProcedure(
        'cdr',
        1,
        function(MACHINE) {
	    var firstArg = checkPair(MACHINE, 'cdr', 0);
	    return firstArg.rest;
        });

    installPrimitiveProcedure(
        'pair?',
        1,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    return isPair(firstArg);
        });

    installPrimitiveProcedure(
        'set-car!',
        2,
        function(MACHINE) {
	    var firstArg = checkPair(MACHINE, 'set-car!', 0);
	    var secondArg = MACHINE.env[MACHINE.env.length-2];
	    firstArg.first = secondArg;
            return VOID;
        });


    installPrimitiveProcedure(
        'set-cdr!',
        2,
        function(MACHINE) {
	    var firstArg = checkPair(MACHINE, 'set-car!', 0);
	    var secondArg = MACHINE.env[MACHINE.env.length-2];
	    firstArg.rest = secondArg;
            return VOID;
        });

    
    installPrimitiveProcedure(
        'not',
        1,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    return (firstArg === false);
        });


    installPrimitiveProcedure(
        'null?',
        1,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    return firstArg === NULL;
        });


    installPrimitiveProcedure(
        'vector',
        plt.baselib.arity.makeArityAtLeast(0),
        function(MACHINE) {
	    var i;
	    var result = [];
	    for (i = 0; i < MACHINE.argcount; i++) {
	        result.push(MACHINE.env[MACHINE.env.length-1-i]);
	    }
	    var newVector = makeVector.apply(null, result);
            return newVector;
        });


    installPrimitiveProcedure(
        'vector->list',
        1,
        function(MACHINE) {
	    var elts = checkVector(MACHINE, 'vector->list', 0).elts;
	    var i;
	    var result = NULL;
	    for (i = 0; i < elts.length; i++) {
	        result = makePair(elts[elts.length - 1 - i], result);
	    }
	    return result;
        });

    
    installPrimitiveProcedure(
        'list->vector',
        1,
        function(MACHINE) {
	    var firstArg = checkList(MACHINE, 'list->vector', 0);
	    var result = [];
	    while (firstArg !== NULL) {
	        result.push(firstArg.first);
	        firstArg = firstArg.rest;
	    }
            return makeVector.apply(null, result);
        });


    installPrimitiveProcedure(
        'vector-ref',
        2,
        function(MACHINE) {
	    var elts = checkVector(MACHINE, 'vector-ref', 0).elts;
	    var index = MACHINE.env[MACHINE.env.length-2];
	    return elts[index];
        });


    installPrimitiveProcedure(
        'vector-set!',
        3,
        function(MACHINE) {
	    var elts = checkVector(MACHINE, 'vector-set!', 0).elts;
            // FIXME: check out-of-bounds vector
	    var index = plt.baselib.numbers.toFixnum(
                checkNatural(MACHINE, 'vector-set!', 1));
	    var val = MACHINE.env[MACHINE.env.length - 1 - 2];
	    elts[index] = val;
	    return VOID;
        });


    installPrimitiveProcedure(
        'vector-length',
        1,
        function(MACHINE) {
	    return checkVector(MACHINE, 'vector-length', 0).elts.length;
        });


    installPrimitiveProcedure(
        'make-vector',
        makeList(1, 2),
        function(MACHINE) {
	    var value = 0;
	    var length = plt.baselib.numbers.toFixnum(
                checkNatural(MACHINE, 'make-vector', 0));
	    if (MACHINE.argcount == 2) {
	        value = MACHINE.env[MACHINE.env.length - 2];
	    }
	    var arr = [];
	    for(var i = 0; i < length; i++) {
	        arr[i] = value;
	    }
            return makeVector.apply(null, arr);
        });
    


    installPrimitiveProcedure(
        'symbol?',
        1,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    return isSymbol(firstArg);
        });

    installPrimitiveProcedure(
        'symbol->string',
        1,
        function(MACHINE) {
	    var firstArg = checkSymbol(MACHINE, 'symbol->string', 0);
	    return firstArg.toString();
        });

    installPrimitiveProcedure(
        'string-append',
        plt.baselib.arity.makeArityAtLeast(0),
        function(MACHINE) {
	    var buffer = [];
	    var i;
	    for (i = 0; i < MACHINE.argcount; i++) {
	        buffer.push(checkString(MACHINE, 'string-append', i).toString());
	    }
	    return buffer.join('');
        });

    installPrimitiveProcedure(
        'string-length',
        1,
        function(MACHINE) {
	    var firstArg = checkString(MACHINE, 'string-length', 0).toString();
	    return firstArg.length;
        });
    
    installPrimitiveProcedure(
        'box',
        1,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    return makeBox(firstArg);
        });

    installPrimitiveProcedure(
        'unbox',
        1,
        function(MACHINE) {
	    var firstArg = checkBox(MACHINE, 'unbox', 0);
            return firstArg.ref();
        });

    installPrimitiveProcedure(
        'set-box!',
        2,
        function(MACHINE) {
	    var firstArg = checkMutableBox(MACHINE, 'set-box!', 0);
	    var secondArg = MACHINE.env[MACHINE.env.length-2];
            firstArg.set(secondArg);
	    return VOID;
        });

    installPrimitiveProcedure(
        'void',
        plt.baselib.arity.makeArityAtLeast(0),
        function(MACHINE) {
	    return VOID;
        });

    installPrimitiveProcedure(
        'eq?',
        2,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    var secondArg = MACHINE.env[MACHINE.env.length-2];
	    return firstArg === secondArg;
        });

    installPrimitiveProcedure(
        'equal?',
        2,
        function(MACHINE) {
	    var firstArg = MACHINE.env[MACHINE.env.length-1];
	    var secondArg = MACHINE.env[MACHINE.env.length-2];
	    return equals(firstArg, secondArg);
        });



    installPrimitiveProcedure(
        'member',
        2,
        function(MACHINE) {
	    var x = MACHINE.env[MACHINE.env.length-1];
	    var lst = MACHINE.env[MACHINE.env.length-2];
	    var originalLst = lst;
	    while (true) {
	        if (lst === NULL) {
		    return false;
	        }
	        if (! isPair(lst)) {
		    raiseArgumentTypeError(MACHINE,
                                           'member',
                                           'list',
                                           1,
                                           MACHINE.env[MACHINE.env.length - 1 - 1]);
	        }
	        if (equals(x, (lst.first))) {
		    return lst;
	        }
	        lst = lst.rest;
	    }	
        });
    


    installPrimitiveProcedure(
        'reverse',
        1,
        function(MACHINE) {
	    var rev = NULL;
	    var lst = MACHINE.env[MACHINE.env.length-1];
	    while(lst !== NULL) {
	        testArgument(MACHINE,
			     'pair', isPair, lst, 0, 'reverse');
	        rev = makePair(lst.first, rev);
	        lst = lst.rest;
	    }
	    return rev;
        });




    installPrimitiveProcedure(
        'abs',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.abs(
                checkNumber(MACHINE, 'abs', 0));
        });

    installPrimitiveProcedure(
        'acos',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.acos(
                checkNumber(MACHINE, 'acos', 0));
        });


    installPrimitiveProcedure(
        'asin',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.asin(
                checkNumber(MACHINE, 'asin', 0));
        });

    installPrimitiveProcedure(
        'sin',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.sin(
                checkNumber(MACHINE, 'sin', 0));
        });



    installPrimitiveProcedure(
        'sinh',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.sinh(
                checkNumber(MACHINE, 'sinh', 0));
        });


    installPrimitiveProcedure(
        'tan',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.tan(
                checkNumber(MACHINE, 'tan', 0));
        });

    

    installPrimitiveProcedure(
        'atan',
        makeList(1, 2),
        function(MACHINE) {
            if (MACHINE.argcount === 1) {
		return plt.baselib.numbers.atan(
                    checkNumber(MACHINE, 'atan', 0));
            } else {
                testArgument(MACHINE,
                             'number',
                             isNumber,
                             MACHINE.env[MACHINE.env.length - 1],
                             0,
                             'atan');
                testArgument(MACHINE,
                             'number',
                             isNumber,
                             MACHINE.env[MACHINE.env.length - 2],
                             1,
                             'atan');
                return plt.baselib.numbers.makeFloat(
		    Math.atan2(
                        plt.baselib.numbers.toFixnum(checkNumber(MACHINE, 'atan', 0)),
                        plt.baselib.numbers.toFixnum(checkNumber(MACHINE, 'atan', 1))));
            }
        });


    installPrimitiveProcedure(
        'angle',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.angle(
                checkNumber(MACHINE, 'angle', 0));
        });

    installPrimitiveProcedure(
        'magnitude',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.magnitude(
                checkNumber(MACHINE, 'magnitude', 0));
        });

    installPrimitiveProcedure(
        'conjugate',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.conjugate(
                checkNumber(MACHINE, 'conjugate', 0));
        });




    installPrimitiveProcedure(
        'cos',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.cos(
                checkNumber(MACHINE, 'cos', 0));
        });


    installPrimitiveProcedure(
        'cosh',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.cosh(
                checkNumber(MACHINE, 'cosh', 0));
        });

    installPrimitiveProcedure(
        'gcd',
        plt.baselib.arity.makeArityAtLeast(1),
        function(MACHINE) {
            var args = [], i, x;
            for (i = 0; i < MACHINE.argcount; i++) {
                args.push(checkNumber(MACHINE, 'gcd', i));
            }
            x = args.shift();
	    return plt.baselib.numbers.gcd(x, args);
        });

    installPrimitiveProcedure(
        'lcm',
        plt.baselib.arity.makeArityAtLeast(1),
        function(MACHINE) {
            var args = [], i, x;
            for (i = 0; i < MACHINE.argcount; i++) {
                args.push(checkNumber(MACHINE, 'lcm', i));
            }
            x = args.shift();
	    return plt.baselib.numbers.lcm(x, args);
        });




    installPrimitiveProcedure(
        'exp',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.exp(
                checkNumber(MACHINE, 'exp', 0));
        });


    installPrimitiveProcedure(
        'expt',
        2,
        function(MACHINE) {
            return plt.baselib.numbers.expt(
                checkNumber(MACHINE, 'expt', 0),
                checkNumber(MACHINE, 'expt', 1));
        });


    installPrimitiveProcedure(
        'exact?',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.isExact(
                checkNumber(MACHINE, 'exact?', 0));
        });


    installPrimitiveProcedure(
        'integer?',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.isInteger(MACHINE.env[MACHINE.env.length - 1]);
        });



    installPrimitiveProcedure(
        'imag-part',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.imaginaryPart(
                checkNumber(MACHINE, 'imag-part', 0));
        });


    installPrimitiveProcedure(
        'real-part',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.realPart(
                checkNumber(MACHINE, 'real-part', 0));
        });


    installPrimitiveProcedure(
        'make-polar',
        2,
        function(MACHINE) {
            return plt.baselib.numbers.makeComplexPolar(
                checkReal(MACHINE, 'make-polar', 0),
                checkReal(MACHINE, 'make-polar', 1));
        });


    installPrimitiveProcedure(
        'make-rectangular',
        2,
        function(MACHINE) {
            return plt.baselib.numbers.makeComplex(
                checkReal(MACHINE, 'make-rectangular', 0),
                checkReal(MACHINE, 'make-rectangular', 1));
        });

    installPrimitiveProcedure(
        'modulo',
        2,
        function(MACHINE) {
            return plt.baselib.numbers.modulo(
                checkInteger(MACHINE, 'modulo', 0),
                checkInteger(MACHINE, 'modulo', 1));
        });


    installPrimitiveProcedure(
        'remainder',
        2,
        function(MACHINE) {
            return plt.baselib.numbers.remainder(
                checkInteger(MACHINE, 'remainder', 0),
                checkInteger(MACHINE, 'remainder', 1));
        });


    installPrimitiveProcedure(
        'quotient',
        2,
        function(MACHINE) {
            return plt.baselib.numbers.quotient(
                checkInteger(MACHINE, 'quotient', 0),
                checkInteger(MACHINE, 'quotient', 1));
        });



    installPrimitiveProcedure(
        'floor',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.floor(
                checkReal(MACHINE, 'floor', 0));
        });
    

    installPrimitiveProcedure(
        'ceiling',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.ceiling(
                checkReal(MACHINE, 'ceiling', 0));
        });
   

    installPrimitiveProcedure(
        'round',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.round(
                checkReal(MACHINE, 'round', 0));
        });
    

    installPrimitiveProcedure(
        'truncate',
        1,
        function(MACHINE) {
            var n = checkReal(MACHINE, 'truncate', 0);
	    if (plt.baselib.numbers.lessThan(n, 0)) {
		return plt.baselib.numbers.ceiling(n);
	    } else {
		return plt.baselib.numbers.floor(n);
	    }
        });
    

    installPrimitiveProcedure(
        'numerator',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.numerator(
                checkRational(MACHINE, 'numerator', 0));
        });


    installPrimitiveProcedure(
        'denominator',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.denominator(
                checkRational(MACHINE, 'denominator', 0));
        });


    installPrimitiveProcedure(
        'log',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.log(
                checkNumber(MACHINE, 'log', 0));
        });


    installPrimitiveProcedure(
        'sqr',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.sqr(
                checkNumber(MACHINE, 'sqr', 0));
        });




    installPrimitiveProcedure(
        'sqrt',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.sqrt(
                checkNumber(MACHINE, 'sqrt', 0));
        });



    installPrimitiveProcedure(
        'integer-sqrt',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.integerSqrt(
                checkInteger(MACHINE, 'integer-sqrt', 0));
        });



    installPrimitiveProcedure(
        'sgn',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.sign(
                checkInteger(MACHINE, 'sgn', 0));
        });


    installPrimitiveProcedure(
        'number->string',
        1,
        function(MACHINE) {
            return checkNumber(MACHINE, 'number->string', 0).toString();
        });


    installPrimitiveProcedure(
	'string->symbol',
	1,
	function(MACHINE) {
	    return makeSymbol(checkString(MACHINE, 'string->symbol', 0).toString());
	});


    installPrimitiveProcedure(
        'string->number',
        1,
        function(MACHINE) {
            return plt.baselib.numbers.fromString(
                checkString(MACHINE, 'string->number', 0).toString());
        });

    

    installPrimitiveClosure(
        'make-struct-type',
        makeList(4, 5, 6, 7, 8, 9, 10, 11),
        function(MACHINE) {
            withArguments(
                MACHINE,
                4,
                [false, 
	         NULL,
	         false,
	         false,
	         NULL,
	         false,
	         false],
                function(name, 
                         superType,
	                 initFieldCount,
	                 autoFieldCount,
	                 autoV,
	                 props,	 // FIXME: currently ignored
	                 inspector,  // FIXME: currently ignored
	                 procSpec,	 // FIXME: currently ignored
	                 immutables, // FIXME: currently ignored
	                 guard,      // FIXME: currently ignored
                         constructorName
                        ) {

                    // FIXME: typechecks.

                    var structType = plt.baselib.structs.makeStructureType(
                        name,
                        superType,
                        initFieldCount,
                        autoFieldCount,
                        autoV,
                        //props,
                        //inspector,
                        //procSpec,
                        //immutables,
                        guard);

                    var constructorValue = 
                        makePrimitiveProcedure(
                            constructorName,
                            plt.baselib.numbers.toFixnum(initFieldCount),
                            function(MACHINE) {
                                var args = [];
                                for(var i = 0; i < initFieldCount; i++) {
                                    args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
                                }
                                return structType.constructor.apply(null, args);
                            });

                    var predicateValue = 
                        makePrimitiveProcedure(
                            String(name) + "?",
                            1,
                            function(MACHINE) {
                                return structType.predicate(MACHINE.env[MACHINE.env.length - 1]);
                            });

                    var accessorValue = 
                        makePrimitiveProcedure(
                            String(name) + "-accessor",
                            2,
                            function(MACHINE) {
                                // FIXME: typechecks
                                return structType.accessor(
                                    MACHINE.env[MACHINE.env.length - 1],
                                    plt.baselib.numbers.toFixnum(MACHINE.env[MACHINE.env.length - 2]));
                            });
                    accessorValue.structType = structType;

                    var mutatorValue = 
                        makePrimitiveProcedure(
                            String(name) + "-mutator",
                            3,
                            function(MACHINE) {
                                // FIXME: typechecks
                                return structType.mutator(
                                    MACHINE.env[MACHINE.env.length - 1],
                                    plt.baselib.numbers.toFixnum(MACHINE.env[MACHINE.env.length - 2]),
                                    MACHINE.env[MACHINE.env.length - 3]);
                            });
                    mutatorValue.structType = structType;


                    finalizeClosureCall(MACHINE,
                                        structType,
                                        constructorValue,
                                        predicateValue,
                                        accessorValue,
                                        mutatorValue);
                });
        });
        

     installPrimitiveProcedure(
         'current-inspector',
         makeList(0, 1),
         function(MACHINE) {
            if (MACHINE.argcount === 1) {
                MACHINE.params['currentInspector'] = 
                    checkInspector(MACHINE, 'current-inspector', 0);
                return VOID;
            } else {
	        return MACHINE.params['currentInspector'];
            }
         }
     ); 


    installPrimitiveProcedure(
        'make-struct-field-accessor',
        makeList(2, 3),
        function(MACHINE){
            // FIXME: typechecks
            // We must guarantee that the ref argument is good.
            var structType = MACHINE.env[MACHINE.env.length - 1].structType;
            var index = MACHINE.env[MACHINE.env.length - 2];
            var name;
            if (MACHINE.argcount === 3) {
                name = String(MACHINE.env[MACHINE.env.length - 3]);
            } else {
                name = 'field' + index;
            }
            return makePrimitiveProcedure(
                name,
                1,
                function(MACHINE) {
                    return structType.accessor(
                        MACHINE.env[MACHINE.env.length - 1],
                        plt.baselib.numbers.toFixnum(index));
                });
            
        });


    installPrimitiveProcedure(
        'make-struct-field-mutator',
        makeList(2, 3),
        function(MACHINE){
            // FIXME: typechecks
            // We must guarantee that the set! argument is good.
            var structType = MACHINE.env[MACHINE.env.length - 1].structType;
            var index = MACHINE.env[MACHINE.env.length - 2];
            var name;
            if (MACHINE.argcount === 3) {
                name = String(MACHINE.env[MACHINE.env.length - 3]);
            } else {
                name = 'field' + index;
            }
            return makePrimitiveProcedure(
                name,
                2,
                function(MACHINE) {
                    return structType.mutator(
                        MACHINE.env[MACHINE.env.length - 1],
                        plt.baselib.numbers.toFixnum(index),
                        MACHINE.env[MACHINE.env.length - 2]);
                });            
        });






    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////






    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////

    // Implementation of the ready function.  This will fire off when
    // setReadyTrue is called.

    (function(scope) {
        scope.ready = function(f) {
            if (runtimeIsReady) {
                notifyWaiter(f);
            } else {
                readyWaiters.push(f);
            }
        };

        scope.setReadyTrue = function() {
            runtimeIsReady = true;
            while(runtimeIsReady && readyWaiters.length > 0) {
                notifyWaiter(readyWaiters.shift());
            }
        };

        scope.setReadyFalse = function() {
            runtimeIsReady = false;
        };


        var runtimeIsReady = false;
        var readyWaiters = [];
        var notifyWaiter = function(w) {
            w();
        };
    })(this);


    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////

    // Executes all programs that have been labeled as a main module
    var invokeMains = function(machine, succ, fail) {
        runtime.ready(function() {
            setReadyFalse();
            machine = machine || runtime.currentMachine;
            succ = succ || function() {};
            fail = fail || function() {};
            var mainModules = machine.mainModules.slice();
            var loop = function() {
                if (mainModules.length > 0) {
                    var nextModule = mainModules.shift();
                    nextModule.invoke(machine, loop, fail);
                } else {
                    setReadyTrue();
                    succ();
                }
            };
            setTimeout(loop, 0);
        });
    };

    // Looks up a name in any of the machine's main modules.
    var lookupInMains = function(name, machine) {
        machine = machine || runtime.currentMachine;
        for (var i = 0; i < machine.mainModules.length; i++) {
            var ns = machine.mainModules[i].getNamespace();
            if(ns.hasOwnProperty(name)) {
                return ns[name];
            }
        }
    };



    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////


    // Exports
    var exports = runtime;
    exports['currentMachine'] = new Machine();
    exports['invokeMains'] = invokeMains;
    exports['lookupInMains'] = lookupInMains;


    // installing new primitives
    exports['installPrimitiveProcedure'] = installPrimitiveProcedure;
    exports['installPrimitiveClosure'] = installPrimitiveClosure;
    exports['makePrimitiveProcedure'] = makePrimitiveProcedure;
    exports['Primitives'] = Primitives;
    
    exports['ready'] = ready;
    // Private: the runtime library will set this flag to true when
    // the library has finished loading.
    exports['setReadyTrue'] = setReadyTrue;
    exports['setReadyFalse'] = setReadyFalse;

    exports['Machine'] = Machine;
    exports['Frame'] = Frame;
    exports['CallFrame'] = CallFrame;
    exports['PromptFrame'] = PromptFrame;
    exports['Closure'] = Closure;
    exports['ModuleRecord'] = ModuleRecord;
    exports['VariableReference'] = VariableReference;
    exports['ContinuationPromptTag'] = ContinuationPromptTag;
    exports['DEFAULT_CONTINUATION_PROMPT_TAG'] = 
	DEFAULT_CONTINUATION_PROMPT_TAG;
    exports['NULL'] = NULL;
    exports['VOID'] = VOID;

    exports['NEGATIVE_ZERO'] = NEGATIVE_ZERO;
    exports['INF'] = INF;
    exports['NEGATIVE_INF'] = NEGATIVE_INF;
    exports['NAN'] = NAN;





    exports['testArgument'] = testArgument;
    exports['testArity'] = testArity;
    exports['makeCheckArgumentType'] = makeCheckArgumentType;


    exports['raise'] = raise;
    exports['raiseUnboundToplevelError'] = raiseUnboundToplevelError;
    exports['raiseArgumentTypeError'] = raiseArgumentTypeError;
    exports['raiseContextExpectedValuesError'] = raiseContextExpectedValuesError;
    exports['raiseArityMismatchError'] = raiseArityMismatchError;
    exports['raiseOperatorApplicationError'] = raiseOperatorApplicationError;
    exports['raiseOperatorIsNotPrimitiveProcedure'] = raiseOperatorIsNotPrimitiveProcedure;
    exports['raiseOperatorIsNotClosure'] = raiseOperatorIsNotClosure;
    exports['raiseUnimplementedPrimitiveError'] = raiseUnimplementedPrimitiveError;


    exports['captureControl'] = captureControl;
    exports['restoreControl'] = restoreControl;

    exports['trampoline'] = trampoline;
    exports['spliceListIntoStack'] = spliceListIntoStack;
    exports['unspliceRestFromStack'] = unspliceRestFromStack;


    exports['finalizeClosureCall'] = finalizeClosureCall;


    //////////////////////////////////////////////////////////////////////


    // Type constructors

    // numbers
    exports['makeList'] = makeList;
    exports['makePair'] = makePair;
    exports['makeVector'] = makeVector;
    exports['makeBox'] = makeBox;
    exports['makeFloat'] = makeFloat;
    exports['makeRational'] = makeRational;
    exports['makeBignum'] = makeBignum;
    exports['makeComplex'] = makeComplex;
    exports['makeSymbol'] = makeSymbol;


    // Type predicates
    exports['isPair'] = isPair;
    exports['isList'] = isList;
    exports['isVector'] = isVector;
    exports['isOutputPort'] = isOutputPort;
    exports['isOutputStringPort'] = isOutputStringPort;
    exports['isBox'] = isBox;
    exports['isString'] = isString;
    exports['isSymbol'] = isSymbol;
    exports['isNumber'] = isNumber;
    exports['isNatural'] = isNatural;
    exports['isReal'] = isReal;
    exports['equals'] = equals;

    exports['toDomNode'] = toDomNode;
    exports['toWrittenString'] = toWrittenString;
    exports['toDisplayedString'] = toDisplayedString;

    exports['ArityAtLeast'] = plt.baselib.arity.ArityAtLeast;
    exports['makeArityAtLeast'] = plt.baselib.arity.makeArityAtLeast;
    exports['isArityMatching'] = plt.baselib.arity.isArityMatching;

    exports['heir'] = heir;
    exports['makeClassPredicate'] = makeClassPredicate;

    exports['PAUSE'] = PAUSE;
    exports['HaltError'] = HaltError;



    exports['makeStructureType'] = plt.baselib.structs.makeStructureType;
    exports['Struct'] = plt.baselib.structs.Struct;
    exports['StructType'] = plt.baselib.structs.StructType;


})(this['plt']);