# box_maker

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

Latest version **0.0.1** (published 2017-05-04) · 0 weekly downloads

## Install

```sh
npm install box_maker
pnpm add box_maker
yarn add box_maker
bun add box_maker
```

## Health

**Score 10/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support; low quality score; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.0.1 |
| Published | 2017-05-04 |
| First published | 2017-05-04 |
| Weekly downloads | 0 |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Maintainers | joemars305 |

## Links

- npm: https://www.npmjs.com/package/box_maker
- npm.io page: https://npm.io/package/box_maker

## Recent versions

- 0.0.1 (latest) — 2017-05-04

## README

// 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("<procedure-env>")));
    } 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);
}

---
_Source: https://npm.io/package/box_maker · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._