mirror of
https://github.com/atom/atom.git
synced 2026-01-24 14:28:14 -05:00
bc6e2597b0
Only works for TomDoc'd CoffeeScript right now. Needs to work for all languages. I had to modify handlebars to satisfy 'use strict' Also had to modify the path stuff in tdoc, which works in node but not atom. We need some way to install npm packages or something similar maybe?
1494 lines
46 KiB
JavaScript
1494 lines
46 KiB
JavaScript
// lib/handlebars/parser.js
|
|
/* Jison generated parser */
|
|
var handlebars = (function(){
|
|
var parser = {trace: function trace() { },
|
|
yy: {},
|
|
symbols_: {"error":2,"root":3,"program":4,"EOF":5,"statements":6,"simpleInverse":7,"statement":8,"openInverse":9,"closeBlock":10,"openBlock":11,"mustache":12,"partial":13,"CONTENT":14,"COMMENT":15,"OPEN_BLOCK":16,"inMustache":17,"CLOSE":18,"OPEN_INVERSE":19,"OPEN_ENDBLOCK":20,"path":21,"OPEN":22,"OPEN_UNESCAPED":23,"OPEN_PARTIAL":24,"params":25,"hash":26,"param":27,"STRING":28,"INTEGER":29,"BOOLEAN":30,"hashSegments":31,"hashSegment":32,"ID":33,"EQUALS":34,"pathSegments":35,"SEP":36,"$accept":0,"$end":1},
|
|
terminals_: {2:"error",5:"EOF",14:"CONTENT",15:"COMMENT",16:"OPEN_BLOCK",18:"CLOSE",19:"OPEN_INVERSE",20:"OPEN_ENDBLOCK",22:"OPEN",23:"OPEN_UNESCAPED",24:"OPEN_PARTIAL",28:"STRING",29:"INTEGER",30:"BOOLEAN",33:"ID",34:"EQUALS",36:"SEP"},
|
|
productions_: [0,[3,2],[4,3],[4,1],[4,0],[6,1],[6,2],[8,3],[8,3],[8,1],[8,1],[8,1],[8,1],[11,3],[9,3],[10,3],[12,3],[12,3],[13,3],[13,4],[7,2],[17,3],[17,2],[17,2],[17,1],[25,2],[25,1],[27,1],[27,1],[27,1],[27,1],[26,1],[31,2],[31,1],[32,3],[32,3],[32,3],[32,3],[21,1],[35,3],[35,1]],
|
|
performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) {
|
|
|
|
var $0 = $$.length - 1;
|
|
switch (yystate) {
|
|
case 1: return $$[$0-1]
|
|
break;
|
|
case 2: this.$ = new yy.ProgramNode($$[$0-2], $$[$0])
|
|
break;
|
|
case 3: this.$ = new yy.ProgramNode($$[$0])
|
|
break;
|
|
case 4: this.$ = new yy.ProgramNode([])
|
|
break;
|
|
case 5: this.$ = [$$[$0]]
|
|
break;
|
|
case 6: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]
|
|
break;
|
|
case 7: this.$ = new yy.InverseNode($$[$0-2], $$[$0-1], $$[$0])
|
|
break;
|
|
case 8: this.$ = new yy.BlockNode($$[$0-2], $$[$0-1], $$[$0])
|
|
break;
|
|
case 9: this.$ = $$[$0]
|
|
break;
|
|
case 10: this.$ = $$[$0]
|
|
break;
|
|
case 11: this.$ = new yy.ContentNode($$[$0])
|
|
break;
|
|
case 12: this.$ = new yy.CommentNode($$[$0])
|
|
break;
|
|
case 13: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1])
|
|
break;
|
|
case 14: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1])
|
|
break;
|
|
case 15: this.$ = $$[$0-1]
|
|
break;
|
|
case 16: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1])
|
|
break;
|
|
case 17: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1], true)
|
|
break;
|
|
case 18: this.$ = new yy.PartialNode($$[$0-1])
|
|
break;
|
|
case 19: this.$ = new yy.PartialNode($$[$0-2], $$[$0-1])
|
|
break;
|
|
case 20:
|
|
break;
|
|
case 21: this.$ = [[$$[$0-2]].concat($$[$0-1]), $$[$0]]
|
|
break;
|
|
case 22: this.$ = [[$$[$0-1]].concat($$[$0]), null]
|
|
break;
|
|
case 23: this.$ = [[$$[$0-1]], $$[$0]]
|
|
break;
|
|
case 24: this.$ = [[$$[$0]], null]
|
|
break;
|
|
case 25: $$[$0-1].push($$[$0]); this.$ = $$[$0-1];
|
|
break;
|
|
case 26: this.$ = [$$[$0]]
|
|
break;
|
|
case 27: this.$ = $$[$0]
|
|
break;
|
|
case 28: this.$ = new yy.StringNode($$[$0])
|
|
break;
|
|
case 29: this.$ = new yy.IntegerNode($$[$0])
|
|
break;
|
|
case 30: this.$ = new yy.BooleanNode($$[$0])
|
|
break;
|
|
case 31: this.$ = new yy.HashNode($$[$0])
|
|
break;
|
|
case 32: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]
|
|
break;
|
|
case 33: this.$ = [$$[$0]]
|
|
break;
|
|
case 34: this.$ = [$$[$0-2], $$[$0]]
|
|
break;
|
|
case 35: this.$ = [$$[$0-2], new yy.StringNode($$[$0])]
|
|
break;
|
|
case 36: this.$ = [$$[$0-2], new yy.IntegerNode($$[$0])]
|
|
break;
|
|
case 37: this.$ = [$$[$0-2], new yy.BooleanNode($$[$0])]
|
|
break;
|
|
case 38: this.$ = new yy.IdNode($$[$0])
|
|
break;
|
|
case 39: $$[$0-2].push($$[$0]); this.$ = $$[$0-2];
|
|
break;
|
|
case 40: this.$ = [$$[$0]]
|
|
break;
|
|
}
|
|
},
|
|
table: [{3:1,4:2,5:[2,4],6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],24:[1,15]},{1:[3]},{5:[1,16]},{5:[2,3],7:17,8:18,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,19],20:[2,3],22:[1,13],23:[1,14],24:[1,15]},{5:[2,5],14:[2,5],15:[2,5],16:[2,5],19:[2,5],20:[2,5],22:[2,5],23:[2,5],24:[2,5]},{4:20,6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,4],22:[1,13],23:[1,14],24:[1,15]},{4:21,6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,4],22:[1,13],23:[1,14],24:[1,15]},{5:[2,9],14:[2,9],15:[2,9],16:[2,9],19:[2,9],20:[2,9],22:[2,9],23:[2,9],24:[2,9]},{5:[2,10],14:[2,10],15:[2,10],16:[2,10],19:[2,10],20:[2,10],22:[2,10],23:[2,10],24:[2,10]},{5:[2,11],14:[2,11],15:[2,11],16:[2,11],19:[2,11],20:[2,11],22:[2,11],23:[2,11],24:[2,11]},{5:[2,12],14:[2,12],15:[2,12],16:[2,12],19:[2,12],20:[2,12],22:[2,12],23:[2,12],24:[2,12]},{17:22,21:23,33:[1,25],35:24},{17:26,21:23,33:[1,25],35:24},{17:27,21:23,33:[1,25],35:24},{17:28,21:23,33:[1,25],35:24},{21:29,33:[1,25],35:24},{1:[2,1]},{6:30,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],24:[1,15]},{5:[2,6],14:[2,6],15:[2,6],16:[2,6],19:[2,6],20:[2,6],22:[2,6],23:[2,6],24:[2,6]},{17:22,18:[1,31],21:23,33:[1,25],35:24},{10:32,20:[1,33]},{10:34,20:[1,33]},{18:[1,35]},{18:[2,24],21:40,25:36,26:37,27:38,28:[1,41],29:[1,42],30:[1,43],31:39,32:44,33:[1,45],35:24},{18:[2,38],28:[2,38],29:[2,38],30:[2,38],33:[2,38],36:[1,46]},{18:[2,40],28:[2,40],29:[2,40],30:[2,40],33:[2,40],36:[2,40]},{18:[1,47]},{18:[1,48]},{18:[1,49]},{18:[1,50],21:51,33:[1,25],35:24},{5:[2,2],8:18,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,2],22:[1,13],23:[1,14],24:[1,15]},{14:[2,20],15:[2,20],16:[2,20],19:[2,20],22:[2,20],23:[2,20],24:[2,20]},{5:[2,7],14:[2,7],15:[2,7],16:[2,7],19:[2,7],20:[2,7],22:[2,7],23:[2,7],24:[2,7]},{21:52,33:[1,25],35:24},{5:[2,8],14:[2,8],15:[2,8],16:[2,8],19:[2,8],20:[2,8],22:[2,8],23:[2,8],24:[2,8]},{14:[2,14],15:[2,14],16:[2,14],19:[2,14],20:[2,14],22:[2,14],23:[2,14],24:[2,14]},{18:[2,22],21:40,26:53,27:54,28:[1,41],29:[1,42],30:[1,43],31:39,32:44,33:[1,45],35:24},{18:[2,23]},{18:[2,26],28:[2,26],29:[2,26],30:[2,26],33:[2,26]},{18:[2,31],32:55,33:[1,56]},{18:[2,27],28:[2,27],29:[2,27],30:[2,27],33:[2,27]},{18:[2,28],28:[2,28],29:[2,28],30:[2,28],33:[2,28]},{18:[2,29],28:[2,29],29:[2,29],30:[2,29],33:[2,29]},{18:[2,30],28:[2,30],29:[2,30],30:[2,30],33:[2,30]},{18:[2,33],33:[2,33]},{18:[2,40],28:[2,40],29:[2,40],30:[2,40],33:[2,40],34:[1,57],36:[2,40]},{33:[1,58]},{14:[2,13],15:[2,13],16:[2,13],19:[2,13],20:[2,13],22:[2,13],23:[2,13],24:[2,13]},{5:[2,16],14:[2,16],15:[2,16],16:[2,16],19:[2,16],20:[2,16],22:[2,16],23:[2,16],24:[2,16]},{5:[2,17],14:[2,17],15:[2,17],16:[2,17],19:[2,17],20:[2,17],22:[2,17],23:[2,17],24:[2,17]},{5:[2,18],14:[2,18],15:[2,18],16:[2,18],19:[2,18],20:[2,18],22:[2,18],23:[2,18],24:[2,18]},{18:[1,59]},{18:[1,60]},{18:[2,21]},{18:[2,25],28:[2,25],29:[2,25],30:[2,25],33:[2,25]},{18:[2,32],33:[2,32]},{34:[1,57]},{21:61,28:[1,62],29:[1,63],30:[1,64],33:[1,25],35:24},{18:[2,39],28:[2,39],29:[2,39],30:[2,39],33:[2,39],36:[2,39]},{5:[2,19],14:[2,19],15:[2,19],16:[2,19],19:[2,19],20:[2,19],22:[2,19],23:[2,19],24:[2,19]},{5:[2,15],14:[2,15],15:[2,15],16:[2,15],19:[2,15],20:[2,15],22:[2,15],23:[2,15],24:[2,15]},{18:[2,34],33:[2,34]},{18:[2,35],33:[2,35]},{18:[2,36],33:[2,36]},{18:[2,37],33:[2,37]}],
|
|
defaultActions: {16:[2,1],37:[2,23],53:[2,21]},
|
|
parseError: function parseError(str, hash) {
|
|
throw new Error(str);
|
|
},
|
|
parse: function parse(input) {
|
|
var self = this,
|
|
stack = [0],
|
|
vstack = [null], // semantic value stack
|
|
lstack = [], // location stack
|
|
table = this.table,
|
|
yytext = '',
|
|
yylineno = 0,
|
|
yyleng = 0,
|
|
recovering = 0,
|
|
TERROR = 2,
|
|
EOF = 1;
|
|
|
|
//this.reductionCount = this.shiftCount = 0;
|
|
|
|
this.lexer.setInput(input);
|
|
this.lexer.yy = this.yy;
|
|
this.yy.lexer = this.lexer;
|
|
if (typeof this.lexer.yylloc == 'undefined')
|
|
this.lexer.yylloc = {};
|
|
var yyloc = this.lexer.yylloc;
|
|
lstack.push(yyloc);
|
|
|
|
if (typeof this.yy.parseError === 'function')
|
|
this.parseError = this.yy.parseError;
|
|
|
|
function popStack (n) {
|
|
stack.length = stack.length - 2*n;
|
|
vstack.length = vstack.length - n;
|
|
lstack.length = lstack.length - n;
|
|
}
|
|
|
|
function lex() {
|
|
var token;
|
|
token = self.lexer.lex() || 1; // $end = 1
|
|
// if token isn't its numeric value, convert
|
|
if (typeof token !== 'number') {
|
|
token = self.symbols_[token] || token;
|
|
}
|
|
return token;
|
|
};
|
|
|
|
var symbol, preErrorSymbol, state, action, a, r, yyval={},p,len,newState, expected;
|
|
while (true) {
|
|
// retreive state number from top of stack
|
|
state = stack[stack.length-1];
|
|
|
|
// use default actions if available
|
|
if (this.defaultActions[state]) {
|
|
action = this.defaultActions[state];
|
|
} else {
|
|
if (symbol == null)
|
|
symbol = lex();
|
|
// read action for current state and first input
|
|
action = table[state] && table[state][symbol];
|
|
}
|
|
|
|
// handle parse error
|
|
if (typeof action === 'undefined' || !action.length || !action[0]) {
|
|
|
|
if (!recovering) {
|
|
// Report error
|
|
expected = [];
|
|
for (p in table[state]) if (this.terminals_[p] && p > 2) {
|
|
expected.push("'"+this.terminals_[p]+"'");
|
|
}
|
|
var errStr = '';
|
|
if (this.lexer.showPosition) {
|
|
errStr = 'Parse error on line '+(yylineno+1)+":\n"+this.lexer.showPosition()+'\nExpecting '+expected.join(', ');
|
|
} else {
|
|
errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " +
|
|
(symbol == 1 /*EOF*/ ? "end of input" :
|
|
("'"+(this.terminals_[symbol] || symbol)+"'"));
|
|
}
|
|
this.parseError(errStr,
|
|
{text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected});
|
|
}
|
|
|
|
// just recovered from another error
|
|
if (recovering == 3) {
|
|
if (symbol == EOF) {
|
|
throw new Error(errStr || 'Parsing halted.');
|
|
}
|
|
|
|
// discard current lookahead and grab another
|
|
yyleng = this.lexer.yyleng;
|
|
yytext = this.lexer.yytext;
|
|
yylineno = this.lexer.yylineno;
|
|
yyloc = this.lexer.yylloc;
|
|
symbol = lex();
|
|
}
|
|
|
|
// try to recover from error
|
|
while (1) {
|
|
// check for error recovery rule in this state
|
|
if ((TERROR.toString()) in table[state]) {
|
|
break;
|
|
}
|
|
if (state == 0) {
|
|
throw new Error(errStr || 'Parsing halted.');
|
|
}
|
|
popStack(1);
|
|
state = stack[stack.length-1];
|
|
}
|
|
|
|
preErrorSymbol = symbol; // save the lookahead token
|
|
symbol = TERROR; // insert generic error symbol as new lookahead
|
|
state = stack[stack.length-1];
|
|
action = table[state] && table[state][TERROR];
|
|
recovering = 3; // allow 3 real symbols to be shifted before reporting a new error
|
|
}
|
|
|
|
// this shouldn't happen, unless resolve defaults are off
|
|
if (action[0] instanceof Array && action.length > 1) {
|
|
throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol);
|
|
}
|
|
|
|
switch (action[0]) {
|
|
|
|
case 1: // shift
|
|
//this.shiftCount++;
|
|
|
|
stack.push(symbol);
|
|
vstack.push(this.lexer.yytext);
|
|
lstack.push(this.lexer.yylloc);
|
|
stack.push(action[1]); // push state
|
|
symbol = null;
|
|
if (!preErrorSymbol) { // normal execution/no error
|
|
yyleng = this.lexer.yyleng;
|
|
yytext = this.lexer.yytext;
|
|
yylineno = this.lexer.yylineno;
|
|
yyloc = this.lexer.yylloc;
|
|
if (recovering > 0)
|
|
recovering--;
|
|
} else { // error just occurred, resume old lookahead f/ before error
|
|
symbol = preErrorSymbol;
|
|
preErrorSymbol = null;
|
|
}
|
|
break;
|
|
|
|
case 2: // reduce
|
|
//this.reductionCount++;
|
|
|
|
len = this.productions_[action[1]][1];
|
|
|
|
// perform semantic action
|
|
yyval.$ = vstack[vstack.length-len]; // default to $$ = $1
|
|
// default location, uses first token for firsts, last for lasts
|
|
yyval._$ = {
|
|
first_line: lstack[lstack.length-(len||1)].first_line,
|
|
last_line: lstack[lstack.length-1].last_line,
|
|
first_column: lstack[lstack.length-(len||1)].first_column,
|
|
last_column: lstack[lstack.length-1].last_column
|
|
};
|
|
r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
|
|
|
|
if (typeof r !== 'undefined') {
|
|
return r;
|
|
}
|
|
|
|
// pop off stack
|
|
if (len) {
|
|
stack = stack.slice(0,-1*len*2);
|
|
vstack = vstack.slice(0, -1*len);
|
|
lstack = lstack.slice(0, -1*len);
|
|
}
|
|
|
|
stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce)
|
|
vstack.push(yyval.$);
|
|
lstack.push(yyval._$);
|
|
// goto new state = table[STATE][NONTERMINAL]
|
|
newState = table[stack[stack.length-2]][stack[stack.length-1]];
|
|
stack.push(newState);
|
|
break;
|
|
|
|
case 3: // accept
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
}};/* Jison generated lexer */
|
|
var lexer = (function(){var lexer = ({EOF:1,
|
|
parseError:function parseError(str, hash) {
|
|
if (this.yy.parseError) {
|
|
this.yy.parseError(str, hash);
|
|
} else {
|
|
throw new Error(str);
|
|
}
|
|
},
|
|
setInput:function (input) {
|
|
this._input = input;
|
|
this._more = this._less = this.done = false;
|
|
this.yylineno = this.yyleng = 0;
|
|
this.yytext = this.matched = this.match = '';
|
|
this.conditionStack = ['INITIAL'];
|
|
this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0};
|
|
return this;
|
|
},
|
|
input:function () {
|
|
var ch = this._input[0];
|
|
this.yytext+=ch;
|
|
this.yyleng++;
|
|
this.match+=ch;
|
|
this.matched+=ch;
|
|
var lines = ch.match(/\n/);
|
|
if (lines) this.yylineno++;
|
|
this._input = this._input.slice(1);
|
|
return ch;
|
|
},
|
|
unput:function (ch) {
|
|
this._input = ch + this._input;
|
|
return this;
|
|
},
|
|
more:function () {
|
|
this._more = true;
|
|
return this;
|
|
},
|
|
pastInput:function () {
|
|
var past = this.matched.substr(0, this.matched.length - this.match.length);
|
|
return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
|
|
},
|
|
upcomingInput:function () {
|
|
var next = this.match;
|
|
if (next.length < 20) {
|
|
next += this._input.substr(0, 20-next.length);
|
|
}
|
|
return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, "");
|
|
},
|
|
showPosition:function () {
|
|
var pre = this.pastInput();
|
|
var c = new Array(pre.length + 1).join("-");
|
|
return pre + this.upcomingInput() + "\n" + c+"^";
|
|
},
|
|
next:function () {
|
|
if (this.done) {
|
|
return this.EOF;
|
|
}
|
|
if (!this._input) this.done = true;
|
|
|
|
var token,
|
|
match,
|
|
col,
|
|
lines;
|
|
if (!this._more) {
|
|
this.yytext = '';
|
|
this.match = '';
|
|
}
|
|
var rules = this._currentRules();
|
|
for (var i=0;i < rules.length; i++) {
|
|
match = this._input.match(this.rules[rules[i]]);
|
|
if (match) {
|
|
lines = match[0].match(/\n.*/g);
|
|
if (lines) this.yylineno += lines.length;
|
|
this.yylloc = {first_line: this.yylloc.last_line,
|
|
last_line: this.yylineno+1,
|
|
first_column: this.yylloc.last_column,
|
|
last_column: lines ? lines[lines.length-1].length-1 : this.yylloc.last_column + match[0].length}
|
|
this.yytext += match[0];
|
|
this.match += match[0];
|
|
this.matches = match;
|
|
this.yyleng = this.yytext.length;
|
|
this._more = false;
|
|
this._input = this._input.slice(match[0].length);
|
|
this.matched += match[0];
|
|
token = this.performAction.call(this, this.yy, this, rules[i],this.conditionStack[this.conditionStack.length-1]);
|
|
if (token) return token;
|
|
else return;
|
|
}
|
|
}
|
|
if (this._input === "") {
|
|
return this.EOF;
|
|
} else {
|
|
this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(),
|
|
{text: "", token: null, line: this.yylineno});
|
|
}
|
|
},
|
|
lex:function lex() {
|
|
var r = this.next();
|
|
if (typeof r !== 'undefined') {
|
|
return r;
|
|
} else {
|
|
return this.lex();
|
|
}
|
|
},
|
|
begin:function begin(condition) {
|
|
this.conditionStack.push(condition);
|
|
},
|
|
popState:function popState() {
|
|
return this.conditionStack.pop();
|
|
},
|
|
_currentRules:function _currentRules() {
|
|
return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules;
|
|
}});
|
|
lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
|
|
|
|
var YYSTATE=YY_START
|
|
switch($avoiding_name_collisions) {
|
|
case 0: this.begin("mu"); if (yy_.yytext) return 14;
|
|
break;
|
|
case 1: return 14;
|
|
break;
|
|
case 2: return 24;
|
|
break;
|
|
case 3: return 16;
|
|
break;
|
|
case 4: return 20;
|
|
break;
|
|
case 5: return 19;
|
|
break;
|
|
case 6: return 19;
|
|
break;
|
|
case 7: return 23;
|
|
break;
|
|
case 8: return 23;
|
|
break;
|
|
case 9: yy_.yytext = yy_.yytext.substr(3,yy_.yyleng-5); this.begin("INITIAL"); return 15;
|
|
break;
|
|
case 10: return 22;
|
|
break;
|
|
case 11: return 34;
|
|
break;
|
|
case 12: return 33;
|
|
break;
|
|
case 13: return 33;
|
|
break;
|
|
case 14: return 36;
|
|
break;
|
|
case 15: /*ignore whitespace*/
|
|
break;
|
|
case 16: this.begin("INITIAL"); return 18;
|
|
break;
|
|
case 17: this.begin("INITIAL"); return 18;
|
|
break;
|
|
case 18: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 28;
|
|
break;
|
|
case 19: return 30;
|
|
break;
|
|
case 20: return 30;
|
|
break;
|
|
case 21: return 29;
|
|
break;
|
|
case 22: return 33;
|
|
break;
|
|
case 23: return 'INVALID';
|
|
break;
|
|
case 24: return 5;
|
|
break;
|
|
}
|
|
};
|
|
lexer.rules = [/^[^\x00]*?(?=(\{\{))/,/^[^\x00]+/,/^\{\{>/,/^\{\{#/,/^\{\{\//,/^\{\{\^/,/^\{\{\s*else\b/,/^\{\{\{/,/^\{\{&/,/^\{\{![\s\S]*?\}\}/,/^\{\{/,/^=/,/^\.(?=[} ])/,/^\.\./,/^[/.]/,/^\s+/,/^\}\}\}/,/^\}\}/,/^"(\\["]|[^"])*"/,/^true(?=[}\s])/,/^false(?=[}\s])/,/^[0-9]+(?=[}\s])/,/^[a-zA-Z0-9_$-]+(?=[=}\s/.])/,/^./,/^$/];
|
|
lexer.conditions = {"mu":{"rules":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24],"inclusive":false},"INITIAL":{"rules":[0,1,24],"inclusive":true}};return lexer;})()
|
|
parser.lexer = lexer;
|
|
return parser;
|
|
})();
|
|
// if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
|
|
// exports.parser = handlebars;
|
|
// exports.parse = function () { return handlebars.parse.apply(handlebars, arguments); }
|
|
// exports.main = function commonjsMain(args) {
|
|
// if (!args[1])
|
|
// throw new Error('Usage: '+args[0]+' FILE');
|
|
// if (typeof process !== 'undefined') {
|
|
// var source = require('fs').readFileSync(require('path').join(process.cwd(), args[1]), "utf8");
|
|
// } else {
|
|
// var cwd = require("file").path(require("file").cwd());
|
|
// var source = cwd.join(args[1]).read({charset: "utf-8"});
|
|
// }
|
|
// return exports.parser.parse(source);
|
|
// }
|
|
// if (typeof module !== 'undefined' && require.main === module) {
|
|
// exports.main(typeof process !== 'undefined' ? process.argv.slice(1) : require("system").args);
|
|
// }
|
|
// };
|
|
// ;
|
|
// lib/handlebars/base.js
|
|
var Handlebars = {};
|
|
|
|
Handlebars.VERSION = "1.0.beta.2";
|
|
|
|
Handlebars.Parser = handlebars;
|
|
|
|
Handlebars.parse = function(string) {
|
|
Handlebars.Parser.yy = Handlebars.AST;
|
|
return Handlebars.Parser.parse(string);
|
|
};
|
|
|
|
Handlebars.print = function(ast) {
|
|
return new Handlebars.PrintVisitor().accept(ast);
|
|
};
|
|
|
|
Handlebars.helpers = {};
|
|
Handlebars.partials = {};
|
|
|
|
Handlebars.registerHelper = function(name, fn, inverse) {
|
|
if(inverse) { fn.not = inverse; }
|
|
this.helpers[name] = fn;
|
|
};
|
|
|
|
Handlebars.registerPartial = function(name, str) {
|
|
this.partials[name] = str;
|
|
};
|
|
|
|
Handlebars.registerHelper('helperMissing', function(arg) {
|
|
if(arguments.length === 2) {
|
|
return undefined;
|
|
} else {
|
|
throw new Error("Could not find property '" + arg + "'");
|
|
}
|
|
});
|
|
|
|
Handlebars.registerHelper('blockHelperMissing', function(context, fn, inverse) {
|
|
inverse = inverse || function() {};
|
|
|
|
var ret = "";
|
|
var type = Object.prototype.toString.call(context);
|
|
|
|
if(type === "[object Function]") {
|
|
context = context();
|
|
}
|
|
|
|
if(context === true) {
|
|
return fn(this);
|
|
} else if(context === false || context == null) {
|
|
return inverse(this);
|
|
} else if(type === "[object Array]") {
|
|
if(context.length > 0) {
|
|
for(var i=0, j=context.length; i<j; i++) {
|
|
ret = ret + fn(context[i]);
|
|
}
|
|
} else {
|
|
ret = inverse(this);
|
|
}
|
|
return ret;
|
|
} else {
|
|
return fn(context);
|
|
}
|
|
}, function(context, fn) {
|
|
return fn(context);
|
|
});
|
|
|
|
Handlebars.registerHelper('each', function(context, fn, inverse) {
|
|
var ret = "";
|
|
|
|
if(context && context.length > 0) {
|
|
for(var i=0, j=context.length; i<j; i++) {
|
|
ret = ret + fn(context[i]);
|
|
}
|
|
} else {
|
|
ret = inverse(this);
|
|
}
|
|
return ret;
|
|
});
|
|
|
|
Handlebars.registerHelper('if', function(context, fn, inverse) {
|
|
if(!context || context == []) {
|
|
return inverse(this);
|
|
} else {
|
|
return fn(this);
|
|
}
|
|
});
|
|
|
|
Handlebars.registerHelper('unless', function(context, fn, inverse) {
|
|
return Handlebars.helpers['if'].call(this, context, inverse, fn);
|
|
});
|
|
|
|
Handlebars.registerHelper('with', function(context, fn) {
|
|
return fn(context);
|
|
});
|
|
|
|
Handlebars.logger = {
|
|
DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
|
|
|
|
// override in the host environment
|
|
log: function(level, str) {}
|
|
};
|
|
|
|
Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); };
|
|
;
|
|
// lib/handlebars/ast.js
|
|
(function() {
|
|
|
|
Handlebars.AST = {};
|
|
|
|
Handlebars.AST.ProgramNode = function(statements, inverse) {
|
|
this.type = "program";
|
|
this.statements = statements;
|
|
if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
|
|
};
|
|
|
|
Handlebars.AST.MustacheNode = function(params, hash, unescaped) {
|
|
this.type = "mustache";
|
|
this.id = params[0];
|
|
this.params = params.slice(1);
|
|
this.hash = hash;
|
|
this.escaped = !unescaped;
|
|
};
|
|
|
|
Handlebars.AST.PartialNode = function(id, context) {
|
|
this.type = "partial";
|
|
|
|
// TODO: disallow complex IDs
|
|
|
|
this.id = id;
|
|
this.context = context;
|
|
};
|
|
|
|
var verifyMatch = function(open, close) {
|
|
if(open.original !== close.original) {
|
|
throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
|
|
}
|
|
};
|
|
|
|
Handlebars.AST.BlockNode = function(mustache, program, close) {
|
|
verifyMatch(mustache.id, close);
|
|
this.type = "block";
|
|
this.mustache = mustache;
|
|
this.program = program;
|
|
};
|
|
|
|
Handlebars.AST.InverseNode = function(mustache, program, close) {
|
|
verifyMatch(mustache.id, close);
|
|
this.type = "inverse";
|
|
this.mustache = mustache;
|
|
this.program = program;
|
|
};
|
|
|
|
Handlebars.AST.ContentNode = function(string) {
|
|
this.type = "content";
|
|
this.string = string;
|
|
};
|
|
|
|
Handlebars.AST.HashNode = function(pairs) {
|
|
this.type = "hash";
|
|
this.pairs = pairs;
|
|
};
|
|
|
|
Handlebars.AST.IdNode = function(parts) {
|
|
this.type = "ID";
|
|
this.original = parts.join(".");
|
|
|
|
var dig = [], depth = 0;
|
|
|
|
for(var i=0,l=parts.length; i<l; i++) {
|
|
var part = parts[i];
|
|
|
|
if(part === "..") { depth++; }
|
|
else if(part === "." || part === "this") { continue; }
|
|
else { dig.push(part); }
|
|
}
|
|
|
|
this.parts = dig;
|
|
this.string = dig.join('.');
|
|
this.depth = depth;
|
|
this.isSimple = (dig.length === 1) && (depth === 0);
|
|
};
|
|
|
|
Handlebars.AST.StringNode = function(string) {
|
|
this.type = "STRING";
|
|
this.string = string;
|
|
};
|
|
|
|
Handlebars.AST.IntegerNode = function(integer) {
|
|
this.type = "INTEGER";
|
|
this.integer = integer;
|
|
};
|
|
|
|
Handlebars.AST.BooleanNode = function(boolean) {
|
|
this.type = "BOOLEAN";
|
|
this.boolean = boolean;
|
|
};
|
|
|
|
Handlebars.AST.CommentNode = function(comment) {
|
|
this.type = "comment";
|
|
this.comment = comment;
|
|
};
|
|
|
|
})();;
|
|
// lib/handlebars/visitor.js
|
|
|
|
Handlebars.Visitor = function() {};
|
|
|
|
Handlebars.Visitor.prototype = {
|
|
accept: function(object) {
|
|
return this[object.type](object);
|
|
}
|
|
};;
|
|
// lib/handlebars/utils.js
|
|
Handlebars.Exception = function(message) {
|
|
this.message = message;
|
|
};
|
|
|
|
// Build out our basic SafeString type
|
|
Handlebars.SafeString = function(string) {
|
|
this.string = string;
|
|
};
|
|
Handlebars.SafeString.prototype.toString = function() {
|
|
return this.string.toString();
|
|
};
|
|
|
|
(function() {
|
|
var escape = {
|
|
"<": "<",
|
|
">": ">",
|
|
'"': """,
|
|
"'": "'",
|
|
"`": "`"
|
|
};
|
|
|
|
var badChars = /&(?!\w+;)|[<>"'`]/g;
|
|
var possible = /[&<>"'`]/;
|
|
|
|
var escapeChar = function(chr) {
|
|
return escape[chr] || "&"
|
|
};
|
|
|
|
Handlebars.Utils = {
|
|
escapeExpression: function(string) {
|
|
// don't escape SafeStrings, since they're already safe
|
|
if (string instanceof Handlebars.SafeString) {
|
|
return string.toString();
|
|
} else if (string == null || string === false) {
|
|
return "";
|
|
}
|
|
|
|
if(!possible.test(string)) { return string; }
|
|
return string.replace(badChars, escapeChar);
|
|
},
|
|
|
|
isEmpty: function(value) {
|
|
if (typeof value === "undefined") {
|
|
return true;
|
|
} else if (value === null) {
|
|
return true;
|
|
} else if (value === false) {
|
|
return true;
|
|
} else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
})();;
|
|
// lib/handlebars/compiler.js
|
|
Handlebars.Compiler = function() {};
|
|
Handlebars.JavaScriptCompiler = function() {};
|
|
|
|
(function(Compiler, JavaScriptCompiler) {
|
|
Compiler.OPCODE_MAP = {
|
|
appendContent: 1,
|
|
getContext: 2,
|
|
lookupWithHelpers: 3,
|
|
lookup: 4,
|
|
append: 5,
|
|
invokeMustache: 6,
|
|
appendEscaped: 7,
|
|
pushString: 8,
|
|
truthyOrFallback: 9,
|
|
functionOrFallback: 10,
|
|
invokeProgram: 11,
|
|
invokePartial: 12,
|
|
push: 13,
|
|
invokeInverse: 14,
|
|
assignToHash: 15,
|
|
pushStringParam: 16
|
|
};
|
|
|
|
Compiler.MULTI_PARAM_OPCODES = {
|
|
appendContent: 1,
|
|
getContext: 1,
|
|
lookupWithHelpers: 1,
|
|
lookup: 1,
|
|
invokeMustache: 2,
|
|
pushString: 1,
|
|
truthyOrFallback: 1,
|
|
functionOrFallback: 1,
|
|
invokeProgram: 2,
|
|
invokePartial: 1,
|
|
push: 1,
|
|
invokeInverse: 1,
|
|
assignToHash: 1,
|
|
pushStringParam: 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 = {
|
|
compiler: Compiler,
|
|
|
|
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, options) {
|
|
this.children = [];
|
|
this.depths = {list: []};
|
|
this.options = options || {};
|
|
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 this.compiler().compile(program, this.options);
|
|
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++) {
|
|
var depth = result.depths.list[i];
|
|
|
|
if(depth < 2) { continue; }
|
|
else { this.addDepth(depth - 1); }
|
|
}
|
|
|
|
return guid;
|
|
},
|
|
|
|
block: function(block) {
|
|
var mustache = block.mustache;
|
|
var depth, child, inverse, inverseGuid;
|
|
|
|
var params = this.setupStackForMustache(mustache);
|
|
|
|
var programGuid = this.compileProgram(block.program);
|
|
|
|
if(block.program.inverse) {
|
|
inverseGuid = this.compileProgram(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');
|
|
},
|
|
|
|
hash: function(hash) {
|
|
var pairs = hash.pairs, pair, val;
|
|
|
|
this.opcode('push', '{}');
|
|
|
|
for(var i=0, l=pairs.length; i<l; i++) {
|
|
pair = pairs[i];
|
|
val = pair[1];
|
|
|
|
this.accept(val);
|
|
this.opcode('assignToHash', pair[0]);
|
|
}
|
|
},
|
|
|
|
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 = this.setupStackForMustache(mustache);
|
|
|
|
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('lookupWithHelpers', 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);
|
|
},
|
|
|
|
INTEGER: function(integer) {
|
|
this.opcode('push', integer.integer);
|
|
},
|
|
|
|
BOOLEAN: function(boolean) {
|
|
this.opcode('push', boolean.boolean);
|
|
},
|
|
|
|
comment: function() {},
|
|
|
|
// HELPERS
|
|
pushParams: function(params) {
|
|
var i = params.length, param;
|
|
|
|
while(i--) {
|
|
param = params[i];
|
|
|
|
if(this.options.stringParams) {
|
|
if(param.depth) {
|
|
this.addDepth(param.depth);
|
|
}
|
|
|
|
this.opcode('getContext', param.depth || 0);
|
|
this.opcode('pushStringParam', param.string);
|
|
} else {
|
|
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);
|
|
}
|
|
},
|
|
|
|
setupStackForMustache: function(mustache) {
|
|
var params = mustache.params;
|
|
|
|
this.pushParams(params);
|
|
|
|
if(mustache.hash) {
|
|
this.hash(mustache.hash);
|
|
} else {
|
|
this.opcode('push', '{}');
|
|
}
|
|
|
|
this.ID(mustache.id);
|
|
|
|
return params;
|
|
}
|
|
};
|
|
|
|
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] || name.indexOf('-') !== -1 || !isNaN(name)) {
|
|
return parent + "['" + name + "']";
|
|
} else if (/^[0-9]+$/.test(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, options) {
|
|
this.environment = environment;
|
|
this.options = options || {};
|
|
|
|
this.preamble();
|
|
|
|
this.stackSlot = 0;
|
|
this.stackVars = [];
|
|
this.registers = {list: []};
|
|
|
|
this.compileChildren(environment, options);
|
|
|
|
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.options.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, options, $depth) {
|
|
try {
|
|
options = options || {};
|
|
var args = [Handlebars, context, options.helpers, options.partials, options.data];
|
|
var depth = Array.prototype.slice.call(arguments, 2);
|
|
args = args.concat(depth);
|
|
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 + ";");
|
|
}
|
|
}
|
|
},
|
|
|
|
lookupWithHelpers: function(name) {
|
|
if(name) {
|
|
var topStack = this.nextStack();
|
|
|
|
var toPush = "if('" + name + "' in helpers) { " + topStack +
|
|
" = " + this.nameLookup('helpers', name, 'helper') +
|
|
"; } else { " + topStack + " = " +
|
|
this.nameLookup('currentContext', name, 'context') +
|
|
"; }";
|
|
|
|
this.source.push(toPush);
|
|
} else {
|
|
this.pushStack("currentContext");
|
|
}
|
|
},
|
|
|
|
lookup: function(name) {
|
|
var topStack = this.topStack();
|
|
this.source.push(topStack + " = " + this.nameLookup(topStack, name, 'context') + ";");
|
|
},
|
|
|
|
pushStringParam: function(string) {
|
|
this.pushStack("currentContext");
|
|
this.pushString(string);
|
|
},
|
|
|
|
pushString: function(string) {
|
|
this.pushStack(this.quotedString(string));
|
|
},
|
|
|
|
push: function(name) {
|
|
this.pushStack(name);
|
|
},
|
|
|
|
invokeMustache: function(paramSize, original) {
|
|
this.populateParams(paramSize, this.quotedString(original), "{}", null, function(nextStack, helperMissingString, id) {
|
|
this.source.push("else if(" + id + "=== undefined) { " + nextStack + " = helpers.helperMissing.call(" + helperMissingString + "); }");
|
|
this.source.push("else { " + nextStack + " = " + id + "; }");
|
|
});
|
|
},
|
|
|
|
invokeProgram: function(guid, paramSize) {
|
|
var inverse = this.programExpression(this.inverse);
|
|
var mainProgram = this.programExpression(guid);
|
|
|
|
this.populateParams(paramSize, null, mainProgram, inverse, function(nextStack, helperMissingString, id) {
|
|
this.source.push("else { " + nextStack + " = helpers.blockHelperMissing.call(" + helperMissingString + "); }");
|
|
});
|
|
},
|
|
|
|
populateParams: function(paramSize, helperId, program, inverse, fn) {
|
|
var id = this.popStack(), nextStack;
|
|
var params = [], param, stringParam;
|
|
|
|
var hash = this.popStack();
|
|
|
|
this.register('tmp1', program);
|
|
this.source.push('tmp1.hash = ' + hash + ';');
|
|
|
|
if(this.options.stringParams) {
|
|
this.source.push('tmp1.contexts = [];');
|
|
}
|
|
|
|
for(var i=0; i<paramSize; i++) {
|
|
param = this.popStack();
|
|
params.push(param);
|
|
|
|
if(this.options.stringParams) {
|
|
this.source.push('tmp1.contexts.push(' + this.popStack() + ');');
|
|
}
|
|
}
|
|
|
|
if(inverse) {
|
|
this.source.push('tmp1.fn = tmp1;');
|
|
this.source.push('tmp1.inverse = ' + inverse + ';');
|
|
}
|
|
|
|
if(this.options.data) {
|
|
this.source.push('tmp1.data = data;');
|
|
}
|
|
|
|
params.push('tmp1');
|
|
|
|
// TODO: This is legacy behavior. Deprecate and remove.
|
|
if(inverse) {
|
|
params.push(inverse);
|
|
}
|
|
|
|
this.populateCall(params, id, helperId || id, fn);
|
|
},
|
|
|
|
populateCall: function(params, id, helperId, fn) {
|
|
var paramString = ["context"].concat(params).join(", ");
|
|
var helperMissingString = ["context"].concat(helperId).concat(params).join(", ");
|
|
|
|
var nextStack = this.nextStack();
|
|
|
|
this.source.push("if(typeof " + id + " === 'function') { " + nextStack + " = " + id + ".call(" + paramString + "); }");
|
|
fn.call(this, nextStack, helperMissingString, id);
|
|
},
|
|
|
|
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);");
|
|
},
|
|
|
|
assignToHash: function(key) {
|
|
var value = this.popStack();
|
|
var hash = this.topStack();
|
|
|
|
this.source.push(hash + "['" + key + "'] = " + value + ";");
|
|
},
|
|
|
|
// HELPERS
|
|
|
|
compiler: JavaScriptCompiler,
|
|
|
|
compileChildren: function(environment, options) {
|
|
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, options);
|
|
}
|
|
|
|
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.options.data) { programParams.push("data"); }
|
|
|
|
for(var i=0, l = depths.length; i<l; i++) {
|
|
var 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(/\\/g, '\\\\')
|
|
.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(" ");
|
|
|
|
var 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, helpers, partials, data, $depth) {
|
|
var args = Array.prototype.slice.call(arguments, 4);
|
|
|
|
return function(context, options) {
|
|
options = options || {};
|
|
|
|
options = {
|
|
helpers: options.helpers || helpers,
|
|
partials: options.partials || partials,
|
|
data: options.data || data
|
|
};
|
|
|
|
return fn.apply(this, [context, options].concat(args));
|
|
};
|
|
},
|
|
program: function(fn, helpers, partials, data) {
|
|
return function(context, options) {
|
|
options = options || {};
|
|
|
|
return fn(context, {
|
|
helpers: options.helpers || helpers,
|
|
partials: options.partials || partials,
|
|
data: options.data || data
|
|
});
|
|
};
|
|
},
|
|
noop: function() { return ""; },
|
|
compile: function(string, options) {
|
|
var ast = Handlebars.parse(string);
|
|
var environment = new Handlebars.Compiler().compile(ast, options);
|
|
return new Handlebars.JavaScriptCompiler().compile(environment, options);
|
|
},
|
|
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: helpers, partials: partials});
|
|
} else {
|
|
partials[name] = Handlebars.VM.compile(partial);
|
|
return partials[name](context, {helpers: helpers, partials: partials});
|
|
}
|
|
}
|
|
};
|
|
|
|
Handlebars.compile = Handlebars.VM.compile;;
|
|
module.exports = Handlebars; |