709 lines
22 KiB
JavaScript
709 lines
22 KiB
JavaScript
//All kinds of conversion passes over the source code
|
|
var jsp = require("acorn");
|
|
var walk = require("acorn/util/walk.js");
|
|
var rnonIdentMember = /[.\-_$a-zA-Z0-9]/g;
|
|
var global = new Function("return this")();
|
|
|
|
function equals( a, b ) {
|
|
if( a.type === b.type ) {
|
|
if( a.type === "MemberExpression" ) {
|
|
return equals( a.object, b.object ) &&
|
|
equals( a.property, b.property );
|
|
}
|
|
else if( a.type === "Identifier" ) {
|
|
return a.name === b.name;
|
|
}
|
|
else if( a.type === "ThisExpression" ) {
|
|
return true;
|
|
}
|
|
else {
|
|
console.log("equals", a, b);
|
|
unhandled();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function getReceiver( expr ) {
|
|
if( expr.type === "MemberExpression" ) {
|
|
return expr.object;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function nodeToString( expr ) {
|
|
if( expr == null || typeof expr !== "object" ) {
|
|
if( expr === void 0 ) {
|
|
return "void 0";
|
|
}
|
|
else if( typeof expr === "string" ) {
|
|
return '"' + safeToEmbedString(expr) + '"';
|
|
}
|
|
return ("" + expr);
|
|
}
|
|
if( expr.type === "Identifier" ) {
|
|
return expr.name;
|
|
}
|
|
else if( expr.type === "MemberExpression" ) {
|
|
if( expr.computed )
|
|
return nodeToString( expr.object ) + "[" + nodeToString( expr.property ) + "]";
|
|
else
|
|
return nodeToString( expr.object ) + "." + nodeToString( expr.property );
|
|
}
|
|
else if( expr.type === "UnaryExpression" ) {
|
|
if( expr.operator === "~" ||
|
|
expr.operator === "-" ||
|
|
expr.operator === "+" ||
|
|
expr.operator === "-" ) {
|
|
return expr.operator + nodeToString( expr.argument );
|
|
}
|
|
return "(" + expr.operator + " " + nodeToString( expr.argument ) + ")";
|
|
}
|
|
else if( expr.type === "Literal" ) {
|
|
return expr.raw;
|
|
}
|
|
else if( expr.type === "BinaryExpression" || expr.type === "LogicalExpression" ) {
|
|
return "("+nodeToString(expr.left) + " " +
|
|
expr.operator + " " +
|
|
nodeToString(expr.right) + ")";
|
|
}
|
|
else if( expr.type === "ThisExpression" ) {
|
|
return "this";
|
|
}
|
|
else if( expr.type === "ObjectExpression") {
|
|
var props = expr.properties;
|
|
var ret = [];
|
|
for( var i = 0, len = props.length; i < len; ++i ) {
|
|
var prop = props[i];
|
|
ret.push( nodeToString(prop.key) + ": " + nodeToString(prop.value));
|
|
}
|
|
return "({"+ret.join(",\n")+"})";
|
|
}
|
|
else if( expr.type === "NewExpression" ) {
|
|
return "new " + nodeToString(expr.callee) + "(" + nodeToString(expr.arguments) +")";
|
|
}
|
|
//assuming it is arguments
|
|
else if( Array.isArray( expr ) ) {
|
|
var tmp = [];
|
|
for( var i = 0, len = expr.length; i < len; ++i ) {
|
|
tmp.push( nodeToString(expr[i]) );
|
|
}
|
|
return tmp.join(", ");
|
|
}
|
|
else if( expr.type === "FunctionExpression" ) {
|
|
var params = [];
|
|
for( var i = 0, len = expr.params.length; i < len; ++i ) {
|
|
params.push( nodeToString(expr.params[i]) );
|
|
}
|
|
}
|
|
else if( expr.type === "BlockStatement" ) {
|
|
var tmp = [];
|
|
for( var i = 0, len = expr.body.length; i < len; ++i ) {
|
|
tmp.push( nodeToString(expr.body[i]) );
|
|
}
|
|
return tmp.join(";\n");
|
|
}
|
|
else if( expr.type === "CallExpression" ) {
|
|
var args = [];
|
|
for( var i = 0, len = expr.arguments.length; i < len; ++i ) {
|
|
args.push( nodeToString(expr.arguments[i]) );
|
|
}
|
|
return nodeToString( expr.callee ) + "("+args.join(",")+")";
|
|
}
|
|
else {
|
|
console.log( "nodeToString", expr );
|
|
unhandled()
|
|
}
|
|
}
|
|
|
|
function DynamicCall( receiver, fnDereference, arg, start, end ) {
|
|
this.receiver = receiver;
|
|
this.fnDereference = fnDereference;
|
|
this.arg = arg;
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
|
|
DynamicCall.prototype.toString = function() {
|
|
return nodeToString(this.fnDereference) + ".call(" +
|
|
nodeToString(this.receiver) + ", " +
|
|
nodeToString(this.arg) +
|
|
")";
|
|
};
|
|
|
|
function DirectCall( receiver, fnName, arg, start, end ) {
|
|
this.receiver = receiver;
|
|
this.fnName = fnName;
|
|
this.arg = arg;
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
DirectCall.prototype.toString = function() {
|
|
return nodeToString(this.receiver) + "." + nodeToString(this.fnName) +
|
|
"(" + nodeToString(this.arg) + ")"
|
|
};
|
|
|
|
|
|
function ConstantReplacement( value, start, end ) {
|
|
this.value = value;
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
|
|
ConstantReplacement.prototype.toString = function() {
|
|
return nodeToString(this.value);
|
|
};
|
|
|
|
function Empty(start, end) {
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
Empty.prototype.toString = function() {
|
|
return "";
|
|
};
|
|
|
|
function Assertion( expr, exprStr, start, end ) {
|
|
this.expr = expr;
|
|
this.exprStr = exprStr;
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
Assertion.prototype.toString = function() {
|
|
return 'ASSERT('+nodeToString(this.expr)+',\n '+this.exprStr+')';
|
|
};
|
|
|
|
function BitFieldRead(mask, start, end, fieldExpr) {
|
|
if (mask === 0) throw new Error("mask cannot be zero");
|
|
this.mask = mask;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.fieldExpr = fieldExpr;
|
|
}
|
|
|
|
BitFieldRead.prototype.getShiftCount = function() {
|
|
var b = 1;
|
|
var shiftCount = 0;
|
|
while ((this.mask & b) === 0) {
|
|
b <<= 1;
|
|
shiftCount++;
|
|
}
|
|
return shiftCount;
|
|
};
|
|
|
|
BitFieldRead.prototype.toString = function() {
|
|
var fieldExpr = this.fieldExpr ? nodeToString(this.fieldExpr) : "bitField";
|
|
var mask = this.mask;
|
|
var shiftCount = this.getShiftCount();
|
|
return shiftCount === 0
|
|
? "(" + fieldExpr + " & " + mask + ")"
|
|
: "((" + fieldExpr + " & " + mask + ") >>> " + shiftCount + ")";
|
|
};
|
|
|
|
function BitFieldCheck(value, inverted, start, end, fieldExpr) {
|
|
this.value = value;
|
|
this.inverted = inverted;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.fieldExpr = fieldExpr;
|
|
}
|
|
|
|
BitFieldCheck.prototype.toString = function() {
|
|
var fieldExpr = this.fieldExpr ? nodeToString(this.fieldExpr) : "bitField";
|
|
var equality = this.inverted ? "===" : "!==";
|
|
return "((" + fieldExpr + " & " + this.value + ") " + equality + " 0)";
|
|
};
|
|
|
|
function InlineSlice(varExpr, collectionExpression, startExpression, endExpression, start, end, isBrowser) {
|
|
this.varExpr = varExpr;
|
|
this.collectionExpression = collectionExpression;
|
|
this.startExpression = startExpression;
|
|
this.endExpression = endExpression;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.isBrowser = isBrowser;
|
|
}
|
|
|
|
InlineSlice.prototype.hasSimpleStartExpression =
|
|
function InlineSlice$hasSimpleStartExpression() {
|
|
return this.startExpression.type === "Identifier" ||
|
|
this.startExpression.type === "Literal";
|
|
};
|
|
|
|
InlineSlice.prototype.hasSimpleEndExpression =
|
|
function InlineSlice$hasSimpleEndExpression() {
|
|
return this.endExpression.type === "Identifier" ||
|
|
this.endExpression.type === "Literal";
|
|
};
|
|
|
|
InlineSlice.prototype.hasSimpleCollection = function InlineSlice$hasSimpleCollection() {
|
|
return this.collectionExpression.type === "Identifier";
|
|
};
|
|
|
|
InlineSlice.prototype.toString = function InlineSlice$toString() {
|
|
var init = this.hasSimpleCollection()
|
|
? ""
|
|
: "var $_collection = " + nodeToString(this.collectionExpression) + ";";
|
|
|
|
var collectionExpression = this.hasSimpleCollection()
|
|
? nodeToString(this.collectionExpression)
|
|
: "$_collection";
|
|
|
|
|
|
init += "var $_len = " + collectionExpression + ".length;";
|
|
|
|
var varExpr = nodeToString(this.varExpr);
|
|
|
|
//No offset arguments at all
|
|
if( this.startExpression === firstElement ) {
|
|
if (this.isBrowser) {
|
|
return "var " + varExpr + " = [].slice.call("+collectionExpression+");";
|
|
} else {
|
|
return init + "var " + varExpr + " = new Array($_len); " +
|
|
"for(var $_i = 0; $_i < $_len; ++$_i) {" +
|
|
varExpr + "[$_i] = " + collectionExpression + "[$_i];" +
|
|
"}";
|
|
}
|
|
|
|
}
|
|
else {
|
|
if( !this.hasSimpleStartExpression() ) {
|
|
init += "var $_start = " + nodeToString(this.startExpression) + ";";
|
|
}
|
|
var startExpression = this.hasSimpleStartExpression()
|
|
? nodeToString(this.startExpression)
|
|
: "$_start";
|
|
|
|
//Start offset argument given
|
|
if( this.endExpression === lastElement ) {
|
|
if (this.isBrowser) {
|
|
return "var " + varExpr + " = [].slice.call("+collectionExpression+", "+startExpression+");";
|
|
} else {
|
|
return init + "var " + varExpr + " = new Array(Math.max($_len - " +
|
|
startExpression + ", 0)); " +
|
|
"for(var $_i = " + startExpression + "; $_i < $_len; ++$_i) {" +
|
|
varExpr + "[$_i - "+startExpression+"] = " + collectionExpression + "[$_i];" +
|
|
"}";
|
|
}
|
|
}
|
|
//Start and end offset argument given
|
|
else {
|
|
|
|
if( !this.hasSimpleEndExpression() ) {
|
|
init += "var $_end = " + nodeToString(this.endExpression) + ";";
|
|
}
|
|
var endExpression = this.hasSimpleEndExpression()
|
|
? nodeToString(this.endExpression)
|
|
: "$_end";
|
|
|
|
if (this.isBrowser) {
|
|
return "var " + varExpr + " = [].slice.call("+collectionExpression+", "+startExpression+", "+endExpression+");";
|
|
} else {
|
|
return init + "var " + varExpr + " = new Array(Math.max(" + endExpression + " - " +
|
|
startExpression + ", 0)); " +
|
|
"for(var $_i = " + startExpression + "; $_i < " + endExpression + "; ++$_i) {" +
|
|
varExpr + "[$_i - "+startExpression+"] = " + collectionExpression + "[$_i];" +
|
|
"}";
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
var opts = {
|
|
ecmaVersion: 5,
|
|
strictSemicolons: false,
|
|
allowTrailingCommas: true,
|
|
forbidReserved: false,
|
|
locations: false,
|
|
onComment: null,
|
|
ranges: false,
|
|
program: null,
|
|
sourceFile: null
|
|
};
|
|
|
|
var rlineterm = /[\r\n\u2028\u2029]/;
|
|
var rhorizontalws = /[ \t]/;
|
|
|
|
var convertSrc = function( src, results ) {
|
|
if( results.length ) {
|
|
results.sort(function(a, b){
|
|
var ret = a.start - b.start;
|
|
if( ret === 0 ) {
|
|
ret = a.end - b.end;
|
|
}
|
|
return ret;
|
|
});
|
|
for( var i = 1; i < results.length; ++i ) {
|
|
var item = results[i];
|
|
if( item.start === results[i-1].start &&
|
|
item.end === results[i-1].end ) {
|
|
results.splice(i++, 1);
|
|
}
|
|
}
|
|
var ret = "";
|
|
var start = 0;
|
|
for( var i = 0, len = results.length; i < len; ++i ) {
|
|
var item = results[i];
|
|
ret += src.substring( start, item.start );
|
|
ret += item.toString();
|
|
start = item.end;
|
|
}
|
|
ret += src.substring( start );
|
|
return ret;
|
|
}
|
|
return src;
|
|
};
|
|
|
|
var rescape = /[\r\n\u2028\u2029"]/g;
|
|
|
|
var replacer = function( ch ) {
|
|
return "\\u" + (("0000") +
|
|
(ch.charCodeAt(0).toString(16))).slice(-4);
|
|
};
|
|
|
|
function safeToEmbedString( str ) {
|
|
return str.replace( rescape, replacer );
|
|
}
|
|
|
|
function parse( src, opts, fileName) {
|
|
if( !fileName ) {
|
|
fileName = opts;
|
|
opts = void 0;
|
|
}
|
|
try {
|
|
return jsp.parse(src, opts);
|
|
}
|
|
catch(e) {
|
|
e.message = e.message + " " + fileName;
|
|
e.scriptSrc = src;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
var inlinedFunctions = Object.create(null);
|
|
|
|
var lastElement = jsp.parse("___input.length").body[0].expression;
|
|
var firstElement = jsp.parse("0").body[0].expression;
|
|
inlinedFunctions.INLINE_SLICE = function( node, isBrowser ) {
|
|
var statement = node;
|
|
node = node.expression;
|
|
var args = node.arguments;
|
|
|
|
if( !(2 <= args.length && args.length <= 4 ) ) {
|
|
throw new Error("INLINE_SLICE must have exactly 2, 3 or 4 arguments");
|
|
}
|
|
|
|
var varExpression = args[0];
|
|
var collectionExpression = args[1];
|
|
var startExpression = args.length < 3
|
|
? firstElement
|
|
: args[2];
|
|
var endExpression = args.length < 4
|
|
? lastElement
|
|
: args[3];
|
|
return new InlineSlice(varExpression, collectionExpression,
|
|
startExpression, endExpression, statement.start, statement.end, isBrowser);
|
|
};
|
|
inlinedFunctions.BIT_FIELD_READ = function(node) {
|
|
var statement = node;
|
|
var args = node.expression.arguments;
|
|
if (args.length !== 1 && args.length !== 2) {
|
|
throw new Error("BIT_FIELD must have 1 or 2 arguments");
|
|
}
|
|
var arg = args[0];
|
|
if (arg.type !== "Identifier") {
|
|
throw new Error("BIT_FIELD argument must be an identifier");
|
|
}
|
|
var name = arg.name;
|
|
var constant = constants[name];
|
|
if (constant === undefined) {
|
|
throw new Error(name + " is not a constant");
|
|
}
|
|
var value = constant.value;
|
|
return new BitFieldRead(value, statement.start, statement.end, args[1]);
|
|
};
|
|
inlinedFunctions.BIT_FIELD_CHECK = function(node) {
|
|
var statement = node;
|
|
var args = node.expression.arguments;
|
|
if (args.length !== 1 && args.length !== 2) {
|
|
throw new Error("BIT_FIELD must have 1 or 2 arguments");
|
|
}
|
|
var arg = args[0];
|
|
if (arg.type !== "Identifier") {
|
|
throw new Error("BIT_FIELD argument must be an identifier");
|
|
}
|
|
var name = arg.name;
|
|
var constant = constants[name];
|
|
if (constant === undefined) {
|
|
throw new Error(name + " is not a constant");
|
|
}
|
|
var value = constant.value;
|
|
var inverted = false;
|
|
if (name.slice(-4) === "_NEG") {
|
|
inverted = true;
|
|
}
|
|
return new BitFieldCheck(value, inverted, statement.start, statement.end, args[1]);
|
|
};
|
|
inlinedFunctions.USE = function(node) {
|
|
return new Empty(node.start, node.end);
|
|
};
|
|
|
|
var constants = {};
|
|
var ignore = [];
|
|
Error.stackTraceLimit = 10000;
|
|
var astPasses = module.exports = {
|
|
|
|
inlineExpansion: function( src, fileName, isBrowser ) {
|
|
var ast = parse(src, fileName);
|
|
var results = [];
|
|
var expr = [];
|
|
function doInline(node) {
|
|
if( node.expression.type !== 'CallExpression' ) {
|
|
return;
|
|
}
|
|
|
|
var name = node.expression.callee.name;
|
|
|
|
if(typeof inlinedFunctions[ name ] === "function" &&
|
|
expr.indexOf(node.expression) === -1) {
|
|
expr.push(node.expression);
|
|
try {
|
|
results.push( inlinedFunctions[ name ]( node, isBrowser ) );
|
|
}
|
|
catch(e) {
|
|
e.fileName = fileName;
|
|
throw e;
|
|
}
|
|
|
|
}
|
|
}
|
|
walk.simple(ast, {
|
|
ExpressionStatement: doInline,
|
|
CallExpression: function(node) {
|
|
node.expression = node;
|
|
doInline(node);
|
|
}
|
|
});
|
|
var ret = convertSrc( src, results );
|
|
return ret;
|
|
},
|
|
|
|
//Parse constants in from constants.js
|
|
readConstants: function( src, fileName ) {
|
|
var ast = parse(src, fileName);
|
|
walk.simple(ast, {
|
|
ExpressionStatement: function( node ) {
|
|
if( node.expression.type !== 'CallExpression' ) {
|
|
return;
|
|
}
|
|
|
|
var start = node.start;
|
|
var end = node.end;
|
|
node = node.expression;
|
|
var callee = node.callee;
|
|
if( callee.name === "CONSTANT" &&
|
|
callee.type === "Identifier" ) {
|
|
|
|
if( node.arguments.length !== 2 ) {
|
|
throw new Error( "Exactly 2 arguments must be passed to CONSTANT\n" +
|
|
src.substring(start, end)
|
|
);
|
|
}
|
|
|
|
if( node.arguments[0].type !== "Identifier" ) {
|
|
throw new Error( "Can only define identifier as a constant\n" +
|
|
src.substring(start, end)
|
|
);
|
|
}
|
|
|
|
var args = node.arguments;
|
|
|
|
var name = args[0];
|
|
var nameStr = name.name;
|
|
var expr = args[1];
|
|
|
|
var e = eval;
|
|
constants[nameStr] = {
|
|
identifier: name,
|
|
value: e(nodeToString(expr))
|
|
};
|
|
walk.simple( expr, {
|
|
Identifier: function( node ) {
|
|
ignore.push(node);
|
|
}
|
|
});
|
|
global[nameStr] = constants[nameStr].value;
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
//Expand constants in normal source files
|
|
expandConstants: function( src, fileName ) {
|
|
var results = [];
|
|
var identifiers = [];
|
|
var ast = parse(src, fileName);
|
|
walk.simple(ast, {
|
|
Identifier: function( node ) {
|
|
identifiers.push( node );
|
|
}
|
|
});
|
|
|
|
for( var i = 0, len = identifiers.length; i < len; ++i ) {
|
|
var id = identifiers[i];
|
|
if( ignore.indexOf(id) > -1 ) {
|
|
continue;
|
|
}
|
|
var constant = constants[id.name];
|
|
if( constant === void 0 ) {
|
|
continue;
|
|
}
|
|
if( constant.identifier === id ) {
|
|
continue;
|
|
}
|
|
|
|
results.push( new ConstantReplacement( constant.value, id.start, id.end ) );
|
|
|
|
}
|
|
return convertSrc( src, results );
|
|
},
|
|
|
|
removeComments: function( src, fileName ) {
|
|
var results = [];
|
|
var rnoremove = /^[*\s\/]*(?:@preserve|jshint|global)/;
|
|
opts.onComment = function( block, text, start, end ) {
|
|
if( rnoremove.test(text) ) {
|
|
return;
|
|
}
|
|
var e = end + 1;
|
|
var s = start - 1;
|
|
while(rhorizontalws.test(src.charAt(s--)));
|
|
while(rlineterm.test(src.charAt(e++)));
|
|
results.push( new Empty( s + 2, e - 1 ) );
|
|
};
|
|
var ast = parse(src, opts, fileName);
|
|
return convertSrc( src, results );
|
|
},
|
|
|
|
expandAsserts: function( src, fileName ) {
|
|
var ast = parse( src, fileName );
|
|
var results = [];
|
|
walk.simple(ast, {
|
|
CallExpression: function( node ) {
|
|
|
|
var start = node.start;
|
|
var end = node.end;
|
|
var callee = node.callee;
|
|
|
|
if( callee.type === "Identifier" &&
|
|
callee.name === "ASSERT" ) {
|
|
if( node.arguments.length !== 1 ) {
|
|
results.push({
|
|
start: start,
|
|
end: end,
|
|
toString: function() {
|
|
return src.substring(start, end);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
|
|
var expr = node.arguments[0];
|
|
var str = src.substring(expr.start, expr.end);
|
|
str = '"' + safeToEmbedString(str) + '"'
|
|
var assertion = new Assertion( expr, str, start, end );
|
|
|
|
results.push( assertion );
|
|
}
|
|
}
|
|
});
|
|
return convertSrc( src, results );
|
|
},
|
|
|
|
removeAsserts: function( src, fileName ) {
|
|
var ast = parse( src, fileName );
|
|
var results = [];
|
|
walk.simple(ast, {
|
|
ExpressionStatement: function( node ) {
|
|
if( node.expression.type !== 'CallExpression' ) {
|
|
return;
|
|
}
|
|
var start = node.start;
|
|
var end = node.end;
|
|
node = node.expression;
|
|
var callee = node.callee;
|
|
|
|
if( callee.type === "Identifier" &&
|
|
callee.name === "ASSERT" ) {
|
|
var e = end + 1;
|
|
var s = start - 1;
|
|
|
|
while(rhorizontalws.test(src.charAt(s--)));
|
|
while(rlineterm.test(src.charAt(e++)));
|
|
results.push( new Empty( s + 2, e - 1) );
|
|
}
|
|
},
|
|
VariableDeclaration: function(node) {
|
|
var start = node.start;
|
|
var end = node.end;
|
|
if (node.kind === 'var' && node.declarations.length === 1) {
|
|
var decl = node.declarations[0];
|
|
if (decl.id.type === "Identifier" &&
|
|
decl.id.name === "ASSERT") {
|
|
var e = end + 1;
|
|
var s = start - 1;
|
|
while(rhorizontalws.test(src.charAt(s--)));
|
|
while(rlineterm.test(src.charAt(e++)));
|
|
results.push( new Empty( s + 2, e - 1) );
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return convertSrc( src, results );
|
|
},
|
|
|
|
asyncConvert: function( src, objName, fnProp, fileName ) {
|
|
var ast = parse( src, fileName );
|
|
|
|
var results = [];
|
|
walk.simple(ast, {
|
|
CallExpression: function( node ) {
|
|
var start = node.start;
|
|
var end = node.end;
|
|
if( node.callee.type === "MemberExpression" &&
|
|
node.callee.object.name === objName &&
|
|
node.callee.property.name === fnProp &&
|
|
node.arguments.length === 3
|
|
) {
|
|
|
|
var args = node.arguments;
|
|
var fnDereference = args[0];
|
|
var dynamicReceiver = args[1];
|
|
var arg = args[2];
|
|
|
|
var receiver = getReceiver(fnDereference);
|
|
|
|
if( receiver == null || !equals(receiver, dynamicReceiver) ) {
|
|
//Have to use fnDereference.call(dynamicReceiver, arg);
|
|
results.push(
|
|
new DynamicCall( dynamicReceiver, fnDereference, arg, start, end )
|
|
);
|
|
}
|
|
else {
|
|
var fnName = fnDereference.property;
|
|
results.push(
|
|
new DirectCall( receiver, fnName, arg, start, end )
|
|
);
|
|
//Can use receiver.fnName( arg );
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
});
|
|
return convertSrc( src, results );
|
|
}
|
|
};
|