// 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 for_each(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 make_register(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 set_contents_(register, value) { return register(misc.SchemeSymbol("set"))(value); }

function make_stack() { 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); current_depth = 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 make_new_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))) { instruction_execution_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 perform_action_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 perform_action_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(cleaned_labels) { misc.display(cleaned_labels); misc.newline(); misc.newline(); labels = cleaned_labels })(misc.map(function(label_basket) { return filter(function(basket_elm) { return !interruption_(basket_elm); }, label_basket); }, labels)); } function dispatch(message) { if (misc.eq_(message, misc.SchemeSymbol("start"))) { set_contents_(pc, the_instruction_sequence); return execute(); } else if (misc.eq_(message, misc.SchemeSymbol("save-labels"))) { return save_labels; } 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) { the_instruction_sequence = seq } } else if (misc.eq_(message, misc.SchemeSymbol("allocate-register"))) { return allocate_register; } else if (misc.eq_(message, misc.SchemeSymbol("get-register"))) { return lookup_register; } else if (misc.eq_(message, misc.SchemeSymbol("install-operations"))) { return function(ops) { the_ops = 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 perform_action_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 insert_at(k, new_elm, lst) { if (misc.null_(lst)) { return misc.list(new_elm); } 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 delete_at(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 set_register_contents_(machine, register_name, 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(controller_text, machine) { return extract_labels(controller_text, function(insts, labels) { update_insts_(insts, labels, machine); return insts; }); }

function extract_labels(text, receive) { if (misc.null_(text)) { return receive([], []); } else { return extract_labels(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 never_encountered_before_symbol_(element, label_table) { 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 update_insts_(insts, labels, machine) { return (function(pc, flag, stack, ops, save_labels) { 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 set_instruction_execution_proc_(inst, proc) { return misc.set_cdr_(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 make_execution_procedure(inst, machine, pc, flag, stack, ops) { if (misc.eq_(misc.car(inst), misc.SchemeSymbol("assign"))) { return make_assign(inst, machine, ops, pc); } else if (misc.eq_(misc.car(inst), misc.SchemeSymbol("test"))) { return make_test(inst, machine, ops, flag, pc); } else if (misc.eq_(misc.car(inst), misc.SchemeSymbol("branch"))) { return make_branch(inst, machine, flag, pc); } else if (misc.eq_(misc.car(inst), misc.SchemeSymbol("goto"))) { return make_goto(inst, machine, pc); } else if (misc.eq_(misc.car(inst), misc.SchemeSymbol("save"))) { return make_save(inst, machine, stack, pc); } else if (misc.eq_(misc.car(inst), misc.SchemeSymbol("restore"))) { return make_restore(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 make_assign(inst, machine, operations, pc) { return (function(target, value_exp) { return (function(value_proc) { return function() { set_contents_(target, value_proc()); 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 advance_pc(pc) { return set_contents_(pc, misc.cdr(get_contents(pc))); }

function make_test(inst, machine, operations, flag, pc) { return (function(condition) { if (operation_exp_(condition)) { return (function(condition_proc) { 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 make_branch(inst, machine, flag, pc) { return (function(dest) { if (label_exp_(dest)) { return function() { return (function(insts) { if (get_contents(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 make_goto(inst, machine, pc) { return (function(dest) { if (label_exp_(dest)) { return function() { return (function(insts) { return set_contents_(pc, insts); })(lookup_label(machine(misc.SchemeSymbol("labels")), label_exp_label(dest))); } } else if (register_exp_(dest)) { return (function(reg) { return function() { return set_contents_(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 make_restore(inst, machine, stack, pc) { return (function(reg_name, reg) { return function() { return (function(popped_stack_elm) { return (function(stack_elm_owner) { if (ownership_respected_(reg_name, 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 ownership_respected_(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 make_perform(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 make_primitive_exp(exp, machine) { if (constant_exp_(exp)) { return (function(c) { return function() { return c; } })(constant_exp_value(exp)); } else if (label_exp_(exp)) { return function() { return (function(insts) { return insts; })(lookup_label(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 register_exp_(exp) { return tagged_list_(exp, misc.SchemeSymbol("reg")); }

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

function constant_exp_(exp) { return tagged_list_(exp, misc.SchemeSymbol("const")); }

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

function label_exp_(exp) { return tagged_list_(exp, misc.SchemeSymbol("label")); }

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

function make_operation_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 operation_exp_(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 tagged_list_(exp, tag) { return misc.eq_(misc.car(exp), tag); }

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

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

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

function self_evaluating_(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 define_variable_(vr, val, env) { return (function(frame) { return (function(eventual_variable) { if (eventual_variable) { return misc.set_cdr_(eventual_variable, 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 make_frame(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 add_binding_to_frame_(vr, val, frame) { misc.set_car_(frame, misc.cons(vr, misc.car(frame))); return misc.set_cdr_(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 setup_environment() { return (function(initial_env) { define_variable_(misc.SchemeSymbol("true"), true, initial_env); 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 user_print(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 compound_procedure_(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 eceval_operations = misc.list(misc.list(misc.SchemeSymbol("variable?"), variable_), misc.list(misc.SchemeSymbol("get-global-environment"), get_global_environment), misc.list(misc.SchemeSymbol("self-evaluating?"), self_evaluating_), misc.list(misc.SchemeSymbol("prompt-for-input"), prompt_for_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); }