tomhuda
660 lines
18 KiB
JavaScript
660 lines
18 KiB
JavaScript
var Handlebars = require("handlebars");
|
|
|
|
// BEGIN(BROWSER)
|
|
Handlebars.Compiler = function() {};
|
|
Handlebars.JavaScriptCompiler = function() {};
|
|
|
|
(function(Compiler, JavaScriptCompiler) {
|
|
Compiler.OPCODE_MAP = {
|
|
appendContent: 1,
|
|
getContext: 2,
|
|
lookupWithFallback: 3,
|
|
lookup: 4,
|
|
append: 5,
|
|
invokeMustache: 6,
|
|
appendEscaped: 7,
|
|
pushString: 8,
|
|
truthyOrFallback: 9,
|
|
functionOrFallback: 10,
|
|
invokeProgram: 11,
|
|
invokePartial: 12,
|
|
push: 13,
|
|
invokeInverse: 14
|
|
};
|
|
|
|
Compiler.MULTI_PARAM_OPCODES = {
|
|
appendContent: 1,
|
|
getContext: 1,
|
|
lookupWithFallback: 1,
|
|
lookup: 1,
|
|
invokeMustache: 2,
|
|
pushString: 1,
|
|
truthyOrFallback: 1,
|
|
functionOrFallback: 1,
|
|
invokeProgram: 2,
|
|
invokePartial: 1,
|
|
push: 1,
|
|
invokeInverse: 1
|
|
};
|
|
|
|
Compiler.DISASSEMBLE_MAP = {};
|
|
|
|
for(var prop in Compiler.OPCODE_MAP) {
|
|
var value = Compiler.OPCODE_MAP[prop];
|
|
Compiler.DISASSEMBLE_MAP[value] = prop;
|
|
}
|
|
|
|
Compiler.multiParamSize = function(code) {
|
|
return Compiler.MULTI_PARAM_OPCODES[Compiler.DISASSEMBLE_MAP[code]];
|
|
};
|
|
|
|
Compiler.prototype = {
|
|
disassemble: function() {
|
|
var opcodes = this.opcodes, opcode, nextCode;
|
|
var out = [], str, name, value;
|
|
|
|
for(var i=0, l=opcodes.length; i<l; i++) {
|
|
opcode = opcodes[i];
|
|
|
|
if(opcode === 'DECLARE') {
|
|
name = opcodes[++i];
|
|
value = opcodes[++i];
|
|
out.push("DECLARE " + name + " = " + value);
|
|
} else {
|
|
str = Compiler.DISASSEMBLE_MAP[opcode];
|
|
|
|
var extraParams = Compiler.multiParamSize(opcode);
|
|
var codes = [];
|
|
|
|
for(var j=0; j<extraParams; j++) {
|
|
nextCode = opcodes[++i];
|
|
|
|
if(typeof nextCode === "string") {
|
|
nextCode = "\"" + nextCode.replace("\n", "\\n") + "\"";
|
|
}
|
|
|
|
codes.push(nextCode);
|
|
}
|
|
|
|
str = str + " " + codes.join(" ");
|
|
|
|
out.push(str);
|
|
}
|
|
}
|
|
|
|
return out.join("\n");
|
|
},
|
|
|
|
guid: 0,
|
|
|
|
compile: function(program) {
|
|
this.children = [];
|
|
this.depths = {list: []};
|
|
return this.program(program);
|
|
},
|
|
|
|
accept: function(node) {
|
|
return this[node.type](node);
|
|
},
|
|
|
|
program: function(program) {
|
|
var statements = program.statements, statement;
|
|
this.opcodes = [];
|
|
|
|
for(var i=0, l=statements.length; i<l; i++) {
|
|
statement = statements[i];
|
|
this[statement.type](statement);
|
|
}
|
|
|
|
this.depths.list = this.depths.list.sort(function(a, b) {
|
|
return a - b;
|
|
});
|
|
|
|
return this;
|
|
},
|
|
|
|
compileProgram: function(program) {
|
|
var result = new Compiler().compile(program);
|
|
var guid = this.guid++;
|
|
|
|
this.usePartial = this.usePartial || result.usePartial;
|
|
|
|
this.children[guid] = result;
|
|
|
|
for(var i=0, l=result.depths.list.length; i<l; i++) {
|
|
depth = result.depths.list[i];
|
|
|
|
if(depth < 2) { continue; }
|
|
else { this.addDepth(depth - 1); }
|
|
}
|
|
|
|
return guid;
|
|
},
|
|
|
|
block: function(block) {
|
|
var mustache = block.mustache;
|
|
var params = mustache.params, depth, child, inverse, inverseGuid;
|
|
|
|
this.pushParams(params);
|
|
|
|
// ID lookup is now on the stack
|
|
this.ID(mustache.id);
|
|
|
|
var programGuid = this.compileProgram(block.program);
|
|
|
|
if(block.program.inverse) {
|
|
inverseGuid = this.compileProgram(block.program.inverse);
|
|
}
|
|
|
|
if(block.program.inverse) {
|
|
this.declare('inverse', inverseGuid);
|
|
}
|
|
|
|
this.opcode('invokeProgram', programGuid, params.length);
|
|
this.declare('inverse', null);
|
|
this.opcode('append');
|
|
},
|
|
|
|
inverse: function(block) {
|
|
this.ID(block.mustache.id);
|
|
var programGuid = this.compileProgram(block.program);
|
|
|
|
this.opcode('invokeInverse', programGuid);
|
|
this.opcode('append');
|
|
},
|
|
|
|
partial: function(partial) {
|
|
var id = partial.id;
|
|
this.usePartial = true;
|
|
|
|
if(partial.context) {
|
|
this.ID(partial.context);
|
|
} else {
|
|
this.opcode('push', 'context');
|
|
}
|
|
|
|
this.opcode('invokePartial', id.original);
|
|
this.opcode('append');
|
|
},
|
|
|
|
content: function(content) {
|
|
this.opcode('appendContent', content.string);
|
|
},
|
|
|
|
mustache: function(mustache) {
|
|
var params = mustache.params;
|
|
|
|
this.pushParams(params);
|
|
this.ID(mustache.id);
|
|
|
|
this.opcode('invokeMustache', params.length, mustache.id.original);
|
|
|
|
if(mustache.escaped) {
|
|
this.opcode('appendEscaped');
|
|
} else {
|
|
this.opcode('append');
|
|
}
|
|
},
|
|
|
|
ID: function(id) {
|
|
this.addDepth(id.depth);
|
|
|
|
this.opcode('getContext', id.depth);
|
|
|
|
this.opcode('lookupWithFallback', id.parts[0] || null);
|
|
|
|
for(var i=1, l=id.parts.length; i<l; i++) {
|
|
this.opcode('lookup', id.parts[i]);
|
|
}
|
|
},
|
|
|
|
STRING: function(string) {
|
|
this.opcode('pushString', string.string);
|
|
},
|
|
|
|
comment: function() {},
|
|
|
|
pushParams: function(params) {
|
|
var i = params.length, param;
|
|
|
|
while(i--) {
|
|
param = params[i];
|
|
this[param.type](param);
|
|
}
|
|
},
|
|
|
|
opcode: function(name, val1, val2) {
|
|
this.opcodes.push(Compiler.OPCODE_MAP[name]);
|
|
if(val1 !== undefined) { this.opcodes.push(val1); }
|
|
if(val2 !== undefined) { this.opcodes.push(val2); }
|
|
},
|
|
|
|
declare: function(name, value) {
|
|
this.opcodes.push('DECLARE');
|
|
this.opcodes.push(name);
|
|
this.opcodes.push(value);
|
|
},
|
|
|
|
addDepth: function(depth) {
|
|
if(depth === 0) { return; }
|
|
|
|
if(!this.depths[depth]) {
|
|
this.depths[depth] = true;
|
|
this.depths.list.push(depth);
|
|
}
|
|
}
|
|
};
|
|
|
|
JavaScriptCompiler.prototype = {
|
|
// PUBLIC API: You can override these methods in a subclass to provide
|
|
// alternative compiled forms for name lookup and buffering semantics
|
|
nameLookup: function(parent, name, type) {
|
|
if(JavaScriptCompiler.RESERVED_WORDS[name]) {
|
|
return parent + "['" + name + "']";
|
|
} else {
|
|
return parent + "." + name;
|
|
}
|
|
},
|
|
|
|
appendToBuffer: function(string) {
|
|
return "buffer = buffer + " + string + ";";
|
|
},
|
|
|
|
initializeBuffer: function() {
|
|
return this.quotedString("");
|
|
},
|
|
// END PUBLIC API
|
|
|
|
compile: function(environment, data) {
|
|
this.environment = environment;
|
|
this.data = data;
|
|
|
|
this.preamble();
|
|
|
|
this.stackSlot = 0;
|
|
this.stackVars = [];
|
|
this.registers = {list: []};
|
|
|
|
this.compileChildren(environment, data);
|
|
|
|
Handlebars.log(Handlebars.logger.DEBUG, environment.disassemble() + "\n\n");
|
|
|
|
var opcodes = environment.opcodes, opcode, name, declareName, declareVal;
|
|
|
|
this.i = 0;
|
|
|
|
for(l=opcodes.length; this.i<l; this.i++) {
|
|
opcode = this.nextOpcode(0);
|
|
|
|
if(opcode[0] === 'DECLARE') {
|
|
this.i = this.i + 2;
|
|
this[opcode[1]] = opcode[2];
|
|
} else {
|
|
this.i = this.i + opcode[1].length;
|
|
this[opcode[0]].apply(this, opcode[1]);
|
|
}
|
|
}
|
|
|
|
return this.createFunction();
|
|
},
|
|
|
|
nextOpcode: function(n) {
|
|
var opcodes = this.environment.opcodes, opcode = opcodes[this.i + n], name, val;
|
|
var extraParams, codes;
|
|
|
|
if(opcode === 'DECLARE') {
|
|
name = opcodes[this.i + 1];
|
|
val = opcodes[this.i + 2];
|
|
return ['DECLARE', name, val];
|
|
} else {
|
|
name = Compiler.DISASSEMBLE_MAP[opcode];
|
|
|
|
extraParams = Compiler.multiParamSize(opcode);
|
|
codes = [];
|
|
|
|
for(var j=0; j<extraParams; j++) {
|
|
codes.push(opcodes[this.i + j + 1 + n]);
|
|
}
|
|
|
|
return [name, codes];
|
|
}
|
|
},
|
|
|
|
eat: function(opcode) {
|
|
this.i = this.i + opcode.length;
|
|
},
|
|
|
|
preamble: function() {
|
|
var out = [];
|
|
out.push("var buffer = " + this.initializeBuffer() + ", currentContext = context");
|
|
|
|
var copies = "helpers = helpers || Handlebars.helpers;";
|
|
if(this.environment.usePartial) { copies = copies + " partials = partials || Handlebars.partials;"; }
|
|
out.push(copies);
|
|
|
|
// track the last context pushed into place to allow skipping the
|
|
// getContext opcode when it would be a noop
|
|
this.lastContext = 0;
|
|
this.source = out;
|
|
},
|
|
|
|
createFunction: function() {
|
|
var container = {
|
|
escapeExpression: Handlebars.Utils.escapeExpression,
|
|
invokePartial: Handlebars.VM.invokePartial,
|
|
programs: [],
|
|
program: function(i, helpers, partials, data) {
|
|
var programWrapper = this.programs[i];
|
|
if(data) {
|
|
return Handlebars.VM.program(this.children[i], helpers, partials, data);
|
|
} else if(programWrapper) {
|
|
return programWrapper;
|
|
} else {
|
|
programWrapper = this.programs[i] = Handlebars.VM.program(this.children[i], helpers, partials);
|
|
return programWrapper;
|
|
}
|
|
},
|
|
programWithDepth: Handlebars.VM.programWithDepth,
|
|
noop: Handlebars.VM.noop
|
|
};
|
|
var locals = this.stackVars.concat(this.registers.list);
|
|
|
|
if(locals.length > 0) {
|
|
this.source[0] = this.source[0] + ", " + locals.join(", ");
|
|
}
|
|
|
|
this.source[0] = this.source[0] + ";";
|
|
|
|
this.source.push("return buffer;");
|
|
|
|
var params = ["Handlebars", "context", "helpers", "partials"];
|
|
|
|
if(this.data) { params.push("data"); }
|
|
|
|
for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
|
|
params.push("depth" + this.environment.depths.list[i]);
|
|
}
|
|
|
|
|
|
if(params.length === 4 && !this.environment.usePartial) { params.pop(); }
|
|
|
|
params.push(this.source.join("\n"));
|
|
|
|
var fn = Function.apply(this, params);
|
|
fn.displayName = "Handlebars.js";
|
|
|
|
Handlebars.log(Handlebars.logger.DEBUG, fn.toString() + "\n\n");
|
|
|
|
container.render = fn;
|
|
|
|
container.children = this.environment.children;
|
|
|
|
return function(context, helpers, partials, data, $depth) {
|
|
try {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
args.unshift(Handlebars);
|
|
return container.render.apply(container, args);
|
|
} catch(e) {
|
|
throw e;
|
|
}
|
|
};
|
|
},
|
|
|
|
appendContent: function(content) {
|
|
this.source.push(this.appendToBuffer(this.quotedString(content)));
|
|
},
|
|
|
|
append: function() {
|
|
var local = this.popStack();
|
|
this.source.push("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }");
|
|
},
|
|
|
|
appendEscaped: function() {
|
|
var opcode = this.nextOpcode(1), extra = "";
|
|
|
|
if(opcode[0] === 'appendContent') {
|
|
extra = " + " + this.quotedString(opcode[1][0]);
|
|
this.eat(opcode);
|
|
}
|
|
|
|
this.source.push(this.appendToBuffer("this.escapeExpression(" + this.popStack() + ")" + extra));
|
|
},
|
|
|
|
getContext: function(depth) {
|
|
if(this.lastContext !== depth) {
|
|
this.lastContext = depth;
|
|
|
|
if(depth === 0) {
|
|
this.source.push("currentContext = context;");
|
|
} else {
|
|
this.source.push("currentContext = depth" + depth + ";");
|
|
}
|
|
}
|
|
},
|
|
|
|
lookupWithFallback: function(name) {
|
|
if(name) {
|
|
this.pushStack(this.nameLookup('currentContext', name, 'context'));
|
|
var topStack = this.topStack();
|
|
this.source.push("if(" + topStack + " === undefined) { " + topStack + " = " + this.nameLookup('helpers', name, 'helper') + "; }");
|
|
} else {
|
|
this.pushStack("currentContext");
|
|
}
|
|
},
|
|
|
|
lookup: function(name) {
|
|
var topStack = this.topStack();
|
|
this.source.push(topStack + " = " + this.nameLookup(topStack, name, 'context') + ";");
|
|
},
|
|
|
|
pushString: function(string) {
|
|
this.pushStack(this.quotedString(string));
|
|
},
|
|
|
|
push: function(name) {
|
|
this.pushStack(name);
|
|
},
|
|
|
|
invokeMustache: function(paramSize, original) {
|
|
var params = ["context"], fn, slot;
|
|
|
|
fn = this.popStack();
|
|
|
|
for(var i=0; i<paramSize; i++) {
|
|
params.push(this.popStack());
|
|
}
|
|
|
|
if(this.data) { params.push("data"); }
|
|
|
|
var paramString = params.join(", ");
|
|
var helperMissing = ["context"].concat(this.quotedString(original)).concat(params.slice(1));
|
|
|
|
slot = this.nextStack();
|
|
|
|
if(paramSize === 0) {
|
|
// TODO: This case is not listed in the mustache spec. Is it important?
|
|
this.source.push("if(typeof " + fn + " === 'function') { " + slot + " = " + fn + ".call(" + paramString + "); }");
|
|
} else {
|
|
this.source.push("if(typeof " + fn + " === 'function') { " + slot + " = " + fn + ".call(" + paramString + "); } else { " + slot + " = helpers.helperMissing.call(" + helperMissing + ") }");
|
|
}
|
|
},
|
|
|
|
invokeProgram: function(guid, paramSize) {
|
|
var inverse = this.programExpression(this.inverse);
|
|
|
|
var fn = this.popStack();
|
|
var id = fn;
|
|
|
|
var params = ["context"];
|
|
var blockMissingParams = ["context", id];
|
|
|
|
for(var i=0; i<paramSize; i++) {
|
|
var param = this.popStack();
|
|
params.push(param);
|
|
blockMissingParams.push(param);
|
|
}
|
|
|
|
var mainProgram = this.programExpression(guid);
|
|
|
|
params.push(mainProgram, inverse);
|
|
blockMissingParams.push(mainProgram, inverse);
|
|
|
|
if(this.data) {
|
|
params.push("data");
|
|
blockMissingParams.push("data");
|
|
}
|
|
|
|
var nextStack = this.nextStack();
|
|
|
|
this.source.push("if(typeof " + id + " === 'function') { " + nextStack + " = " + id + ".call(" + params.join(", ") + "); }");
|
|
this.source.push("else { " + nextStack + " = helpers.blockHelperMissing.call(" + blockMissingParams.join(", ") + "); }");
|
|
},
|
|
|
|
invokeInverse: function(guid) {
|
|
var program = this.programExpression(guid);
|
|
|
|
var blockMissingParams = ["context", this.topStack(), "this.noop", program];
|
|
this.pushStack("helpers.blockHelperMissing.call(" + blockMissingParams.join(", ") + ")");
|
|
},
|
|
|
|
invokePartial: function(context) {
|
|
this.pushStack("this.invokePartial(" + this.nameLookup('partials', context, 'partial') + ", '" + context + "', " + this.popStack() + ", helpers, partials);");
|
|
},
|
|
|
|
// HELPERS
|
|
|
|
compiler: JavaScriptCompiler,
|
|
|
|
compileChildren: function(environment, data) {
|
|
var children = environment.children, child, compiler;
|
|
var compiled = [];
|
|
|
|
for(var i=0, l=children.length; i<l; i++) {
|
|
child = children[i];
|
|
compiler = new this.compiler();
|
|
|
|
compiled[i] = compiler.compile(child, data);
|
|
}
|
|
|
|
environment.rawChildren = children;
|
|
environment.children = compiled;
|
|
},
|
|
|
|
programExpression: function(guid) {
|
|
if(guid == null) { return "this.noop"; }
|
|
|
|
var programParams = [guid, "helpers", "partials"];
|
|
|
|
var depths = this.environment.rawChildren[guid].depths.list;
|
|
|
|
if(this.data) { programParams.push("data"); }
|
|
|
|
for(var i=0, l = depths.length; i<l; i++) {
|
|
depth = depths[i];
|
|
|
|
if(depth === 1) { programParams.push("context"); }
|
|
else { programParams.push("depth" + (depth - 1)); }
|
|
}
|
|
|
|
if(!this.environment.usePartial) {
|
|
if(programParams[3]) {
|
|
programParams[2] = "null";
|
|
} else {
|
|
programParams.pop();
|
|
}
|
|
}
|
|
|
|
if(depths.length === 0) {
|
|
return "this.program(" + programParams.join(", ") + ")";
|
|
} else {
|
|
programParams[0] = "this.children[" + guid + "]";
|
|
return "this.programWithDepth(" + programParams.join(", ") + ")";
|
|
}
|
|
},
|
|
|
|
register: function(name, val) {
|
|
this.useRegister(name);
|
|
this.source.push(name + " = " + val + ";");
|
|
},
|
|
|
|
useRegister: function(name) {
|
|
if(!this.registers[name]) {
|
|
this.registers[name] = true;
|
|
this.registers.list.push(name);
|
|
}
|
|
},
|
|
|
|
pushStack: function(item) {
|
|
this.source.push(this.nextStack() + " = " + item + ";");
|
|
return "stack" + this.stackSlot;
|
|
},
|
|
|
|
nextStack: function() {
|
|
this.stackSlot++;
|
|
if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
|
|
return "stack" + this.stackSlot;
|
|
},
|
|
|
|
popStack: function() {
|
|
return "stack" + this.stackSlot--;
|
|
},
|
|
|
|
topStack: function() {
|
|
return "stack" + this.stackSlot;
|
|
},
|
|
|
|
quotedString: function(str) {
|
|
return '"' + str
|
|
.replace(/\\/, '\\\\')
|
|
.replace(/"/g, '\\"')
|
|
.replace(/\n/g, '\\n')
|
|
.replace(/\r/g, '\\r') + '"';
|
|
}
|
|
};
|
|
|
|
var reservedWords = ("break case catch continue default delete do else finally " +
|
|
"for function if in instanceof new return switch this throw " +
|
|
"try typeof var void while with null true false").split(" ");
|
|
|
|
compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
|
|
|
|
for(var i=0, l=reservedWords.length; i<l; i++) {
|
|
compilerWords[reservedWords[i]] = true;
|
|
}
|
|
|
|
})(Handlebars.Compiler, Handlebars.JavaScriptCompiler);
|
|
|
|
Handlebars.VM = {
|
|
programWithDepth: function(fn) {
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
return function(context) {
|
|
return fn.apply(this, [context].concat(args));
|
|
};
|
|
},
|
|
program: function(fn, helpers, partials, data) {
|
|
return function(context) {
|
|
return fn(context, helpers, partials, data);
|
|
};
|
|
},
|
|
noop: function() { return ""; },
|
|
compile: function(string, data) {
|
|
var ast = Handlebars.parse(string);
|
|
var environment = new Handlebars.Compiler().compile(ast);
|
|
return new Handlebars.JavaScriptCompiler().compile(environment, data);
|
|
},
|
|
invokePartial: function(partial, name, context, helpers, partials) {
|
|
if(partial === undefined) {
|
|
throw new Handlebars.Exception("The partial " + name + " could not be found");
|
|
} else if(partial instanceof Function) {
|
|
return partial(context, helpers, partials);
|
|
} else {
|
|
partials[name] = Handlebars.VM.compile(partial);
|
|
return partials[name](context, helpers, partials);
|
|
}
|
|
}
|
|
};
|
|
|
|
Handlebars.compile = Handlebars.VM.compile;
|
|
// END(BROWSER)
|
|
|