box_maker v0.0.1

// module.exports is at the bottom of the file, press end to get there

var repl = require("repl"); var misc = require("repl_miscellaneous"); var apply = repl.apply;

function foreach(proc, items) { if (misc.null(items)) { return true; } else { if (function(x) { return true; }(proc(misc.car(items)))) { return for_each(proc, misc.cdr(items)); } else { return false; } } }

function make_machine(ops, controller_text) { return (function(machine) { machine(misc.SchemeSymbol("install-operations"))(ops); machine(misc.SchemeSymbol("install-instruction-sequence"))(assemble(controller_text, machine)); return machine; })(make_new_machine()); }

function assoc(thing, alist) { if (misc.null(alist)) { return false; } else { if (misc.eq(misc.car(misc.car(alist)), thing)) { return misc.car(alist); } else { return assoc(thing, misc.cdr(alist)); } } }

function makeregister(name) { return (function(contents) { function dispatch(message) { if (misc.eq(message, misc.SchemeSymbol("get"))) { return contents; } else if (misc.eq_(message, misc.SchemeSymbol("set"))) { return function(value) { contents = value } } else { return misc.error("Unknown request -- REGISTER", message); } } return dispatch; })(misc.SchemeSymbol("unassigned")); }

function get_contents(register) { return register(misc.SchemeSymbol("get")); }

function setcontents(register, value) { return register(misc.SchemeSymbol("set"))(value); }

function makestack() { return (function(s, number_pushes, max_depth, current_depth) { function push(x) { s = misc.cons(x, s); number_pushes = misc.plus_sign(1, number_pushes); current_depth = misc.plus_sign(1, current_depth); max_depth = max(current_depth, max_depth) } function pop() { if (misc.null(s)) { return misc.error("Empty stack -- POP"); } else { return (function(top) { s = misc.cdr(s); currentdepth = misc.minus_sign(current_depth, 1); return top; })(misc.car(s)); } } function initialize() { s = []; number_pushes = 0; max_depth = 0; current_depth = 0; return misc.SchemeSymbol("done"); } function print_statistics() { misc.newline(); return misc.display(misc.list(misc.SchemeSymbol("total-pushes"), misc.SchemeSymbol("="), number_pushes, misc.SchemeSymbol("maximum-depth"), misc.SchemeSymbol("="), max_depth)); } function dispatch(message) { if (misc.eq(message, misc.SchemeSymbol("push"))) { return push; } else if (misc.eq(message, misc.SchemeSymbol("pop"))) { return pop(); } else if (misc.eq(message, misc.SchemeSymbol("initialize"))) { return initialize(); } else if (misc.eq_(message, misc.SchemeSymbol("print-statistics"))) { return print_statistics(); } else { return misc.error("Unknown request -- STACK", message); } } return dispatch; })([], 0, 0, 0); }

function pop(stack) { return stack(misc.SchemeSymbol("pop")); }

function push(stack, value) { return stack(misc.SchemeSymbol("push"))(value); }

function makenew_machine() { return (function(pc, flag, stack, the_instruction_sequence, labels) { return (function(the_ops, register_table) { function save_labels(labels_list) { labels = labels_list } function allocate_register(name) { if (assoc(name, register_table)) { return misc.error("Multiply defined register: ", name); } else { register_table = misc.cons(misc.list(name, make_register(name)), register_table) } ; return misc.SchemeSymbol("register-allocated"); } function lookup_register(name) { return (function(val) { if (val) { return misc.cadr(val); } else { allocate_register(name); return lookup_register(name); } })(assoc(name, register_table)); } function interruption(inst) { return misc.pair(inst) && misc.eq(misc.car(inst), misc.SchemeSymbol("interrupted")); } function execute() { return (function(insts) { if (misc.null(insts)) { return misc.SchemeSymbol("done"); } else if (interruption(misc.car(insts))) { instructionexecution_proc(misc.car(insts))(); return misc.SchemeSymbol("interrupted"); } else { instruction_execution_proc(misc.car(insts))(); return execute(); } })(get_contents(pc)); } function add_breakpoint(label, n) { return performaction_on_binding(label, labels, function(label_basket) { return insert_at(misc.minus_sign(n, 1), misc.cons(misc.SchemeSymbol("interrupted"), make_interrupt(pc)), misc.cdr(label_basket)); }); } function remove_breakpoint(label, n) { return performaction_on_binding(label, labels, function(label_basket) { return delete_at(misc.minus_sign(n, 1), misc.cdr(label_basket)); }); } function remove_all_breakpoints() { return (function(cleanedlabels) { misc.display(cleaned_labels); misc.newline(); misc.newline(); labels = cleaned_labels })(misc.map(function(label_basket) { return filter(function(basket_elm) { return !interruption(basketelm); }, label_basket); }, labels)); } function dispatch(message) { if (misc.eq(message, misc.SchemeSymbol("start"))) { setcontents(pc, theinstruction_sequence); return execute(); } else if (misc.eq(message, misc.SchemeSymbol("save-labels"))) { return savelabels; } else if (misc.eq(message, misc.SchemeSymbol("business-as-usual"))) { return execute(); } else if (misc.eq(message, misc.SchemeSymbol("add-bkpt"))) { return add_breakpoint; } else if (misc.eq(message, misc.SchemeSymbol("remove-bkpt"))) { return remove_breakpoint; } else if (misc.eq(message, misc.SchemeSymbol("remove-all-bkpts"))) { return remove_all_breakpoints; } else if (misc.eq(message, misc.SchemeSymbol("labels"))) { return labels; } else if (misc.eq(message, misc.SchemeSymbol("install-instruction-sequence"))) { return function(seq) { theinstruction_sequence = seq } } else if (misc.eq(message, misc.SchemeSymbol("allocate-register"))) { return allocateregister; } else if (misc.eq(message, misc.SchemeSymbol("get-register"))) { return lookupregister; } else if (misc.eq(message, misc.SchemeSymbol("install-operations"))) { return function(ops) { theops = misc.append(the_ops, ops) } } else if (misc.eq(message, misc.SchemeSymbol("stack"))) { return stack; } else if (misc.eq_(message, misc.SchemeSymbol("operations"))) { return the_ops; } else { return misc.error("Unknown request -- MACHINE", message); } } return dispatch; })(misc.list(misc.list(misc.SchemeSymbol("initialize-stack"), function() { return stack(misc.SchemeSymbol("initialize")); }), misc.list(misc.SchemeSymbol("print-stack-statistics"), function() { return stack(misc.SchemeSymbol("print-statistics")); })), misc.list(misc.list(misc.SchemeSymbol("pc"), pc), misc.list(misc.SchemeSymbol("flag"), flag))); })(make_register(misc.SchemeSymbol("pc")), make_register(misc.SchemeSymbol("flag")), make_stack(), [], []); }

function performaction_on_binding(binding_name, bindings, action_proc) { return (function(label_basket) { if (label_basket) { return misc.set_cdr(label_basket, action_proc(label_basket)); } else { return misc.error("Label not found", label); } })(assoc(binding_name, bindings)); }

function insertat(k, new_elm, lst) { if (misc.null(lst)) { return misc.list(newelm); } else if (zero(k)) { return misc.cons(new_elm, lst); } else { return misc.cons(misc.car(lst), insert_at(misc.minus_sign(k, 1), new_elm, misc.cdr(lst))); } }

function deleteat(k, lst) { if (misc.null(lst)) { return []; } else if (zero_(k)) { return misc.cdr(lst); } else { return misc.cons(misc.car(lst), delete_at(misc.minus_sign(k, 1), misc.cdr(lst))); } }

function start(machine) { return machine(misc.SchemeSymbol("start")); }

function get_register_contents(machine, register_name) { return get_contents(get_register(machine, register_name)); }

function setregister_contents(machine, registername, value) { set_contents(get_register(machine, register_name), value); return misc.SchemeSymbol("done"); }

function get_register(machine, reg_name) { return machine(misc.SchemeSymbol("get-register"))(reg_name); }

function assemble(controllertext, machine) { return extract_labels(controller_text, function(insts, labels) { update_insts(insts, labels, machine); return insts; }); }

function extractlabels(text, receive) { if (misc.null(text)) { return receive([], []); } else { return extractlabels(misc.cdr(text), function(insts, labels) { return (function(next_inst) { if (never_encountered_before_symbol(next_inst, labels)) { return receive(insts, misc.cons(make_label_entry(next_inst, insts), labels)); } else { return receive(misc.cons(make_instruction(next_inst), insts), labels); } })(misc.car(text)); }); } }

function neverencountered_before_symbol(element, labeltable) { if (misc.symbol(element)) { if (!assoc(element, label_table)) { return true; } else { return misc.error("The following label has been encountered more than once:", element); } } else { return false; } }

function updateinsts(insts, labels, machine) { return (function(pc, flag, stack, ops, savelabels) { return for_each(function(inst) { return set_instruction_execution_proc(inst, make_execution_procedure(instruction_text(inst), machine, pc, flag, stack, ops)); }, insts); })(get_register(machine, misc.SchemeSymbol("pc")), get_register(machine, misc.SchemeSymbol("flag")), machine(misc.SchemeSymbol("stack")), machine(misc.SchemeSymbol("operations")), machine(misc.SchemeSymbol("save-labels"))(labels)); }

function make_instruction(text) { return misc.cons(text, []); }

function instruction_text(inst) { return misc.car(inst); }

function instruction_execution_proc(inst) { return misc.cdr(inst); }

function setinstruction_execution_proc(inst, proc) { return misc.setcdr(inst, proc); }

function make_label_entry(label_name, insts) { return misc.cons(label_name, insts); }

function lookup_label(labels, label_name) { return (function(val) { if (val) { return misc.cdr(val); } else { return misc.error("Undefined label -- ASSEMBLE", label_name); } })(assoc(label_name, labels)); }

function makeexecution_procedure(inst, machine, pc, flag, stack, ops) { if (misc.eq(misc.car(inst), misc.SchemeSymbol("assign"))) { return makeassign(inst, machine, ops, pc); } else if (misc.eq(misc.car(inst), misc.SchemeSymbol("test"))) { return maketest(inst, machine, ops, flag, pc); } else if (misc.eq(misc.car(inst), misc.SchemeSymbol("branch"))) { return makebranch(inst, machine, flag, pc); } else if (misc.eq(misc.car(inst), misc.SchemeSymbol("goto"))) { return makegoto(inst, machine, pc); } else if (misc.eq(misc.car(inst), misc.SchemeSymbol("save"))) { return makesave(inst, machine, stack, pc); } else if (misc.eq(misc.car(inst), misc.SchemeSymbol("restore"))) { return makerestore(inst, machine, stack, pc); } else if (misc.eq(misc.car(inst), misc.SchemeSymbol("perform"))) { return make_perform(inst, machine, ops, pc); } else { return misc.error("Unknown instruction type -- ASSEMBLE", inst); } }

function makeassign(inst, machine, operations, pc) { return (function(target, value_exp) { return (function(value_proc) { return function() { set_contents(target, valueproc()); return advance_pc(pc); } })(function() { if (operation_exp(value_exp)) { return make_operation_exp(value_exp, machine, operations); } else { return make_primitive_exp(misc.car(value_exp), machine); } }()); })(get_register(machine, assign_reg_name(inst)), assign_value_exp(inst)); }

function assign_reg_name(assign_instruction) { return misc.cadr(assign_instruction); }

function assign_value_exp(assign_instruction) { return misc.cddr(assign_instruction); }

function advancepc(pc) { return set_contents(pc, misc.cdr(get_contents(pc))); }

function maketest(inst, machine, operations, flag, pc) { return (function(condition) { if (operation_exp(condition)) { return (function(conditionproc) { return function() { set_contents(flag, condition_proc()); return advance_pc(pc); } })(make_operation_exp(condition, machine, operations)); } else { return misc.error("Bad TEST instruction -- ASSEMBLE", inst); } })(test_condition(inst)); }

function test_condition(test_instruction) { return misc.cdr(test_instruction); }

function makebranch(inst, machine, flag, pc) { return (function(dest) { if (label_exp(dest)) { return function() { return (function(insts) { if (getcontents(flag)) { return set_contents(pc, insts); } else { return advance_pc(pc); } })(lookup_label(machine(misc.SchemeSymbol("labels")), label_exp_label(dest))); } } else { return misc.error("Bad BRANCH instruction -- ASSEMBLE", inst); } })(branch_dest(inst)); }

function branch_dest(branch_instruction) { return misc.cadr(branch_instruction); }

function makegoto(inst, machine, pc) { return (function(dest) { if (label_exp(dest)) { return function() { return (function(insts) { return setcontents(pc, insts); })(lookuplabel(machine(misc.SchemeSymbol("labels")), label_exp_label(dest))); } } else if (register_exp(dest)) { return (function(reg) { return function() { return setcontents(pc, get_contents(reg)); } })(get_register(machine, register_exp_reg(dest))); } else { return misc.error("Bad GOTO instruction -- ASSEMBLE", inst); } })(goto_dest(inst)); }

function goto_dest(goto_instruction) { return misc.cadr(goto_instruction); }

function make_save(inst, machine, stack, pc) { return (function(reg_name, reg) { return function() { push(stack, misc.list(reg_name, get_contents(reg))); return advance_pc(pc); } })(stack_inst_reg_name(inst), get_register(machine, stack_inst_reg_name(inst))); }

function make_interrupt(pc) { return function() { misc.display("stopped."); misc.newline(); return advance_pc(pc); } }

function makerestore(inst, machine, stack, pc) { return (function(reg_name, reg) { return function() { return (function(popped_stack_elm) { return (function(stack_elm_owner) { if (ownership_respected(regname, stack_elm_owner)) { set_contents(reg, stack_elm_value(popped_stack_elm)); return advance_pc(pc); } else { return misc.error("Wrong restore order:", reg_name); } })(stack_elm_owner_name(popped_stack_elm)); })(pop(stack)); } })(stack_inst_reg_name(inst), get_register(machine, stack_inst_reg_name(inst))); }

function stack_elm_value(elm) { return misc.cadr(elm); }

function ownershiprespected(name1, name2) { return misc.eq_(name1, name2); }

function stack_elm_owner_name(elm) { return misc.car(elm); }

function stack_inst_reg_name(stack_instruction) { return misc.cadr(stack_instruction); }

function makeperform(inst, machine, operations, pc) { return (function(action) { if (operation_exp(action)) { return (function(action_proc) { return function() { action_proc(); return advance_pc(pc); } })(make_operation_exp(action, machine, operations)); } else { return misc.error("Bad PERFORM instruction -- ASSEMBLE", inst); } })(perform_action(inst)); }

function perform_action(inst) { return misc.cdr(inst); }

function makeprimitive_exp(exp, machine) { if (constant_exp(exp)) { return (function(c) { return function() { return c; } })(constantexp_value(exp)); } else if (label_exp(exp)) { return function() { return (function(insts) { return insts; })(lookuplabel(machine(misc.SchemeSymbol("labels")), label_exp_label(exp))); } } else if (register_exp(exp)) { return (function(r) { return function() { return get_contents(r); } })(get_register(machine, register_exp_reg(exp))); } else { return misc.error("Unknown expression type -- ASSEMBLE", exp); } }

function registerexp(exp) { return taggedlist(exp, misc.SchemeSymbol("reg")); }

function register_exp_reg(exp) { return misc.cadr(exp); }

function constantexp(exp) { return taggedlist(exp, misc.SchemeSymbol("const")); }

function constant_exp_value(exp) { return misc.cadr(exp); }

function labelexp(exp) { return taggedlist(exp, misc.SchemeSymbol("label")); }

function label_exp_label(exp) { return misc.cadr(exp); }

function makeoperation_exp(exp, machine, operations) { return (function(op, aprocs) { return function() { return op.apply(this, misc.flatten_list(misc.map(function(p) { return p(); }, aprocs))); } })(lookup_prim(operation_exp_op(exp), operations), misc.map(function(e) { if (!label_exp(e)) { return make_primitive_exp(e, machine); } else { return misc.error("You can't use a label as an operator in a machine operation.", e); } }, operation_exp_operands(exp))); }

function proceed_machine(machine) { return machine(misc.SchemeSymbol("business-as-usual")); }

function operationexp(exp) { return misc.pair(exp) && tagged_list(misc.car(exp), misc.SchemeSymbol("op")); }

function operation_exp_op(operation_exp) { return misc.cadr(misc.car(operation_exp)); }

function operation_exp_operands(operation_exp) { return misc.cdr(operation_exp); }

function lookup_prim(symbol, operations) { return (function(val) { if (val) { return misc.cadr(val); } else { return misc.error("Unknown operation -- ASSEMBLE", symbol); } })(assoc(symbol, operations)); }

function taggedlist(exp, tag) { return misc.eq_(misc.car(exp), tag); }

function setbreakpoint(machine, label, n) { return machine(misc.SchemeSymbol("add-bkpt"))(label, n); }

function cancelbreakpoint(machine, label, n) { return machine(misc.SchemeSymbol("remove-bkpt"))(label, n); }

function cancelall_breakpoints(machine) { return machine(misc.SchemeSymbol("remove-all-bkpts"))(); }

function selfevaluating(exp) { return misc.number(exp) || misc.string(exp); }

function variable(exp) { return misc.symbol(exp); }

function quoted_(exp) { return tagged_list(exp, misc.SchemeSymbol("quote")); }

function assignment_(exp) { return tagged_list(exp, misc.SchemeSymbol("set!")); }

function definition_(exp) { return tagged_list(exp, misc.SchemeSymbol("define")); }

function if_(exp) { return tagged_list(exp, misc.SchemeSymbol("if")); }

function lambda_(exp) { return tagged_list(exp, misc.SchemeSymbol("lambda")); }

function begin_(exp) { return tagged_list(exp, misc.SchemeSymbol("begin")); }

function application(exp) { return misc.pair(exp); }

function definevariable(vr, val, env) { return (function(frame) { return (function(eventualvariable) { if (eventual_variable) { return misc.set_cdr(eventualvariable, val); } else { return misc.set_car(env, misc.cons(misc.cons(vr, val), misc.car(env))); } })(assoc(vr, frame)); })(first_frame(env)); }

function enclosing_environment(env) { return misc.cdr(env); }

function first_frame(env) { return misc.car(env); }

function makeframe(variables, values) { if (misc.null(variables)) { return []; } else { return misc.cons(misc.cons(misc.car(variables), misc.car(values)), make_frame(misc.cdr(variables), misc.cdr(values))); } }

function frame_variables(frame) { return misc.car(frame); }

function frame_values(frame) { return misc.cdr(frame); }

function addbinding_to_frame(vr, val, frame) { misc.setcar(frame, misc.cons(vr, misc.car(frame))); return misc.setcdr(frame, misc.cons(val, misc.cdr(frame))); }

function extend_environment(vars, vals, base_env) { if (misc.numeric_equality(misc.length(vars), misc.length(vals))) { return misc.cons(make_frame(vars, vals), base_env); } else { if (misc.numeric_inferiority(misc.length(vars), misc.length(vals))) { return misc.error("Too many arguments supplied", vars, vals); } else { return misc.error("Too few arguments supplied", vars, vals); } } }

function setupenvironment() { return (function(initial_env) { define_variable(misc.SchemeSymbol("true"), true, initialenv); define_variable(misc.SchemeSymbol("false"), false, initial_env); return initial_env; })(the_template_environment); }

var the_template_environment = [[], []];

function prompt_for_input(string) { misc.newline(); misc.newline(); misc.display(string); return misc.newline(); }

function announce_output(string) { misc.newline(); misc.display(string); return misc.newline(); }

function userprint(object) { if (compound_procedure(object)) { return misc.display(misc.list(misc.SchemeSymbol("compound-procedure"), procedure_parameters(object), procedure_body(object), misc.SchemeSymbol(""))); } else { return misc.display(object); } }

function compoundprocedure(p) { if (misc.pair(p)) { return tagged_list(p, misc.SchemeSymbol("procedure")); } else { return false; } }

function procedure_parameters(p) { return misc.cadr(p); }

function procedure_body(p) { return misc.caddr(p); }

function get_global_environment() { return the_global_environment; }

var the_global_environment = setup_environment();

var ecevaloperations = misc.list(misc.list(misc.SchemeSymbol("variable?"), variable), misc.list(misc.SchemeSymbol("get-global-environment"), getglobal_environment), misc.list(misc.SchemeSymbol("self-evaluating?"), self_evaluating), misc.list(misc.SchemeSymbol("prompt-for-input"), promptfor_input), misc.list(misc.SchemeSymbol("quoted?"), quoted), misc.list(misc.SchemeSymbol("assignment?"), assignment), misc.list(misc.SchemeSymbol("definition?"), definition), misc.list(misc.SchemeSymbol("if?"), if), misc.list(misc.SchemeSymbol("lambda?"), lambda), misc.list(misc.SchemeSymbol("begin?"), begin), misc.list(misc.SchemeSymbol("application?"), application), misc.list(misc.SchemeSymbol("read"), misc.read), misc.list(misc.SchemeSymbol("announce-output"), announce_output), misc.list(misc.SchemeSymbol("user-print"), user_print));

var eceval = make_machine(eceval_operations, [misc.SchemeSymbol("read-eval-print-loop"), [[misc.SchemeSymbol("perform"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("initialize-stack"), []]], []]], [[misc.SchemeSymbol("perform"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("prompt-for-input"), []]], [[misc.SchemeSymbol("const"), [";;; EC-Eval input:", []]], []]]], [[misc.SchemeSymbol("assign"), [misc.SchemeSymbol("exp"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("read"), []]], []]]], [[misc.SchemeSymbol("assign"), [misc.SchemeSymbol("env"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("get-global-environment"), []]], []]]], [[misc.SchemeSymbol("assign"), [misc.SchemeSymbol("continue"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("print-result"), []]], []]]], [[misc.SchemeSymbol("goto"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("eval-dispatch"), []]], []]], [misc.SchemeSymbol("print-result"), [[misc.SchemeSymbol("perform"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("announce-output"), []]], [[misc.SchemeSymbol("const"), [";;; EC-Eval value:", []]], []]]], [[misc.SchemeSymbol("perform"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("user-print"), []]], [[misc.SchemeSymbol("reg"), [misc.SchemeSymbol("val"), []]], []]]], [[misc.SchemeSymbol("goto"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("read-eval-print-loop"), []]], []]], [misc.SchemeSymbol("eval-dispatch"), [[misc.SchemeSymbol("test"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("self-evaluating?"), []]], [[misc.SchemeSymbol("reg"), [misc.SchemeSymbol("exp"), []]], []]]], [[misc.SchemeSymbol("branch"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("ev-self-eval"), []]], []]], [[misc.SchemeSymbol("goto"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("unknown-expression-type"), []]], []]], [misc.SchemeSymbol("ev-self-eval"), [[misc.SchemeSymbol("assign"), [misc.SchemeSymbol("val"), [[misc.SchemeSymbol("reg"), [misc.SchemeSymbol("exp"), []]], []]]], [[misc.SchemeSymbol("goto"), [[misc.SchemeSymbol("reg"), [misc.SchemeSymbol("continue"), []]], []]], [misc.SchemeSymbol("unknown-expression-type"), [[misc.SchemeSymbol("assign"), [misc.SchemeSymbol("val"), [[misc.SchemeSymbol("const"), ["ERROR: unknown-expression-type", []]], []]]], [[misc.SchemeSymbol("goto"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("signal-error"), []]], []]], [misc.SchemeSymbol("unknown-procedure-type"), [[misc.SchemeSymbol("restore"), [misc.SchemeSymbol("continue"), []]], [[misc.SchemeSymbol("assign"), [misc.SchemeSymbol("val"), [[misc.SchemeSymbol("const"), ["ERROR unknown-procedure-type", []]], []]]], [[misc.SchemeSymbol("goto"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("signal-error"), []]], []]], [misc.SchemeSymbol("signal-error"), [[misc.SchemeSymbol("perform"), [[misc.SchemeSymbol("op"), [misc.SchemeSymbol("user-print"), []]], [[misc.SchemeSymbol("reg"), [misc.SchemeSymbol("val"), []]], []]]], [[misc.SchemeSymbol("goto"), [[misc.SchemeSymbol("label"), [misc.SchemeSymbol("read-eval-print-loop"), []]], []]], []]]]]]]]]]]]]]]]]]]]]]]]]]]]]);

module.exports = function() { start(eceval); }