jcompile.js

// # jcompile.js
//
// Pretty-printer for parsed Simplified JavaScript,
// written in Simplified JavaScript.
//
// This is also a "compiler" for our parse tree to a form which can be
// 'eval'ed and run natively in the browser JavaScript engine.  At the
// moment we're not doing any transforms, so it's not a very interesting
// compiler.
//
// C. Scott Ananian
// 2010-07-02ish
define(["text!jcompile.js","str-escape"], function make_jcompile(jcompile_source,str_escape) {
    var jcompile, jcompile_stmt, jcompile_stmts;
    var indentation, prec_stack = [ 0 ];

    var assert = function(b, obj) {
        if (!b) { console.assert(b, "Assertion failure", obj); }
    };

    // helper function for delimiter-joined lists
    var gather = function(lst, delim, f) {
        var i = 0, result = [];
        while ( i < lst.length ) {
            result.push(f(lst[i]));
            i += 1;
        }
        return result.join(delim);
    };

    // indentation level
    var nl = function() {
        var n = indentation, result = "\n";
        while (n > 0) {
            result += "  ";
            n -= 1;
        }
        return result;
    };

    // set the precedence to 'prec' when evaluating f
    var with_prec = function(prec, f, obj) {
        return function() {
            var result;
            prec_stack.push(prec);
            result = f.apply(obj || this, arguments);
            prec_stack.pop();
            return result;
        };
    };
    // set the precedence, and parenthesize the result if appropriate.
    var with_prec_paren = function(prec, f, obj) {
        return function() {
            var prev_prec = prec_stack[prec_stack.length - 1];
            var result = with_prec(prec, f).apply(obj || this, arguments);
            if (prev_prec > prec) { result = "(" + result + ")"; }
            return result;
        };
    };

    var dispatch = {};
    dispatch.name = function() {
        return this.value+"/*"+this.scope.level+(this.scope.escape[this.value]?"e":"")+"*/";
    };
    dispatch.literal = function() {
        if (this.value === undefined) { return "undefined"; }
        if (this.value === null) { return "null"; }
        if (typeof(this.value)==='object') {
            if (this.value.length === 0) { return "Array"; }
            return "Object";
        }
        if (typeof(this.value)==='string') { return str_escape(this.value); }
        return this.value.toString();
    };

    // UNARY ASTs
    dispatch.unary = function() {
        assert(dispatch.unary[this.value], this);
        return dispatch.unary[this.value].apply(this);
    };
    var unary = function(op, prec, f) {
        dispatch.unary[op] = f || with_prec_paren(prec, function() {
                return this.value + jcompile(this.first);
            });
    };
    unary('!', 70);
    unary('-', 70);
    unary('typeof', 70, with_prec_paren(70, function() {
                return "typeof("+with_prec(0, jcompile)(this.first)+")";
            }));
    unary('[', 90/*???*/, with_prec_paren(90, function() {
                // new array creation
                return "[" + gather(this.first, ", ", with_prec(0, jcompile)) +
                    "]";
            }));
    unary('{', 90/*???*/, with_prec_paren(90, function() {
                // new object creation
                var result = "{";
                if (this.first.length > 0) {
                    indentation += 1;
                    result += nl();
                    result += gather(this.first, ","+nl(), function(item) {
                            // XXX suppress quotes around item.key when
                            //     unnecessary
                            return str_escape(item.key) + ": " +
                                with_prec(0, jcompile)(item);
                        });
                    indentation -= 1;
                    result += nl();
                }
                result +="}";
                return result;
            }));

    // Binary ASTs
    dispatch.binary = function() {
        assert(dispatch.binary[this.value], this);
        return dispatch.binary[this.value].apply(this);
    };
    var binary = function(op, prec, f, is_right) {
        // with_prec_paren will add parentheses if necessary
        dispatch.binary[op] = f || with_prec_paren(prec, function() {
                var result = jcompile(this.first)+' '+this.value+' ';
                // handle left associativity
                result += with_prec(is_right ? (prec-1) : (prec+1),
                                    jcompile)(this.second);
                return result;
            });
    };
    var binaryr = function(op, prec) { binary(op, prec, null, 1/*is right*/); };
    binaryr('=', 10);
    binaryr('+=', 10);
    binaryr('-=', 10);
    binaryr('*=', 10);
    binaryr('/=', 10);
    binaryr('||', 30);
    binaryr('&&', 35);
    binaryr('===',40);
    binaryr('!==',40);
    binaryr('<', 45);
    binaryr('<=',45);
    binaryr('>', 45);
    binaryr('>=',45);
    binary('+', 50);
    binary('-', 50);
    binary('*', 60);
    binary('/', 60);
    binary(".", 80, with_prec_paren(80, function() {
            assert(this.second.arity==='literal', this.second);
            return jcompile(this.first)+"."+this.second.value;
            }));
    binary('[', 80, with_prec_paren(80, function() {
                return jcompile(this.first) + "[" +
                    with_prec(0, jcompile)(this.second) + "]";
            }));
    binary('(', 75, with_prec_paren(75, function() {
            // simple method invocation (doesn't set 'this')
            var first = jcompile(this.first);
            // catch weird case where standard javascript fails to parse an
            // immediate application of a function expression.
            if (this.first.arity==='function') {
                first = "(" + first + ")";
            }
            return first + "(" +
                gather(this.second, ", ", with_prec(0, jcompile)) + ")";
            }));

    // Ternary ASTs
    dispatch.ternary = function() {
        assert(dispatch.ternary[this.value], this);
        return dispatch.ternary[this.value].apply(this);
    };
    var ternary = function(op, prec, f) {
        dispatch.ternary[op] = with_prec_paren(prec, f);
    };
    ternary("?", 20, function() {
            return jcompile(this.first) + " ? " +
                jcompile(this.second) + " : " +
                jcompile(this.third);
        });
    ternary("(", 80, function() {
        // precedence is 80, same as . and '(')
        var result = jcompile(this.first);
        if (this.second.arity==='literal' &&
            typeof(this.second.value)==='string') {
            result += '.' + this.second.value;
        } else {
            result += '[' + jcompile(this.second) + ']';
        }
        result +=
            "(" + gather(this.third, ", ", with_prec(0, jcompile)) + ")";
        return result;
    });

    // Statements
    dispatch.statement = function() {
        assert(dispatch.statement[this.value], this);
        return dispatch.statement[this.value].apply(this);
    };
    var stmt = function(value, f) {
        dispatch.statement[value] = f;
    };
    stmt("block", function() {
            var result = "{";
            if (this.first.length > 0) {
                indentation += 1;
                result += nl() + jcompile_stmts(this.first);
                indentation -= 1;
            }
            result += nl() + "}";
            return result;
            });
    stmt("var", function() {
            return "var "+jcompile(this.first)+";";
        });
    stmt("if", function() {
            var result = "if ("+jcompile(this.first)+") ";
            // this.second.value === block
            result += jcompile(this.second);
            if (this.third) {
                result += " else ";
                result += jcompile(this.third);
            }
            return result;
        });
    stmt("return", function() {
            return "return"+(this.first ? (" "+jcompile(this.first)) : "")+";";
        });
    stmt("break", function() {
            return "break;";
        });
    stmt("while", function() {
            return "while ("+jcompile(this.first)+") "+jcompile(this.second);
        });

    // Odd cases
    dispatch['this'] = function() { return "this"; }; // literal
    dispatch['function'] = with_prec(0, function() {
            var result = "function";
            if (this.name) { result += " " + this.name; }
            result += " (" + gather(this.first, ", ", jcompile) + ") {";
            if (this.second.length > 0) {
                indentation += 1;
                result += nl() + jcompile_stmts(this.second); // function body
                indentation -= 1;
            }
            result += nl() + "}";
            return result;
        });

    // Helpers
    jcompile = function(tree) {
        // make 'this' the parse tree in the dispatched function.
        assert(dispatch[tree.arity], tree);
        return dispatch[tree.arity].apply(tree);
    };
    jcompile_stmt = function(tree) {
        return jcompile(tree)+(tree.arity==='statement' ? "" : ";");
    };
    jcompile_stmts = function(tree_list) {
        return gather(tree_list, nl(), jcompile_stmt);
    };

    var j = function (parse_tree) {
        // parse_tree should be an array of statements.
        indentation = 0;
        prec_stack = [ 0 ];
        return jcompile_stmts(parse_tree);
    };
    j.__module_name__ = "jcompile";
    j.__module_init__ = make_jcompile;
    j.__module_deps__ = ['str-escape'];
    j.__module_source__ = jcompile_source;
    return j;
});