archive-gh-me/marko
1
0
Fork 0
mirror of https://github.com/marko-js/marko.git synced 2025-12-08 19:26:05 +00:00
Code Issues Projects Releases Wiki Activity

Marko v3: Provide both parseExpression and parseStatement

Browse Source
This commit is contained in:
Patrick Steele-Idem 2016-02-12 17:14:13 -07:00
parent f49638a6dd
commit e59e50b790
4 changed files with 265 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
compiler/Builder.js
View File

@ -46,6 +46,7 @@ var Scriptlet = require('./ast/Scriptlet');
var ContainerNode = require('./ast/ContainerNode'); var ContainerNode = require('./ast/ContainerNode');
var parseExpression = require('./util/parseExpression'); var parseExpression = require('./util/parseExpression');
var parseStatement = require('./util/parseStatement');
var parseJavaScriptArgs = require('./util/parseJavaScriptArgs'); var parseJavaScriptArgs = require('./util/parseJavaScriptArgs');
var isValidJavaScriptIdentifier = require('./util/isValidJavaScriptIdentifier'); var isValidJavaScriptIdentifier = require('./util/isValidJavaScriptIdentifier');
@ -385,6 +386,12 @@ class Builder {
return parseJavaScriptArgs(args, DEFAULT_BUILDER); return parseJavaScriptArgs(args, DEFAULT_BUILDER);
} }
parseStatement(str, options) {
ok(typeof str === 'string', '"str" should be a string expression');
var parsed = parseStatement(str, DEFAULT_BUILDER);
return parsed;
}
program(body) { program(body) {
return new Program({body}); return new Program({body});
} }

238
compiler/util/parseExpression.js
View File

@ -1,235 +1,5 @@
'use strict'; var parseJavaScript = require('./parseJavaScript');
var ok = require('assert').ok;
var charProps = require('char-props');
const esprima = require('esprima'); module.exports = function(src, builder) {
return parseJavaScript(src, builder, true /* isExpression */ );
function parseExpression(src, builder) { };
ok(typeof src === 'string', '"src" should be a string expression');
ok(builder, '"builder" is required');
function convert(node) {
if (Array.isArray(node)) {
let nodes = node;
for (let i=0; i<nodes.length; i++) {
var converted = convert(nodes[i]);
if (converted == null) {
return null;
}
nodes[i] = converted;
}
return nodes;
}
switch(node.type) {
case 'ArrayExpression': {
let elements = convert(node.elements);
if (!elements) {
return null;
}
return builder.arrayExpression(elements);
}
case 'AssignmentExpression': {
let left = convert(node.left);
if (!left) {
return null;
}
let right = convert(node.right);
if (!right) {
return null;
}
return builder.assignment(left, right, node.operator);
}
case 'BinaryExpression': {
let left = convert(node.left);
if (!left) {
return null;
}
let right = convert(node.right);
if (!right) {
return null;
}
return builder.binaryExpression(left, node.operator, right);
}
case 'CallExpression': {
let callee = convert(node.callee);
if (!callee) {
return null;
}
let args = convert(node.arguments);
if (!args) {
return null;
}
return builder.functionCall(callee, args);
}
case 'ConditionalExpression': {
let test = convert(node.test);
if (!test) {
return null;
}
let consequent = convert(node.consequent);
if (!consequent) {
return null;
}
let alternate = convert(node.alternate);
if (!alternate) {
return null;
}
return builder.conditionalExpression(test, consequent, alternate);
}
case 'ExpressionStatement': {
return convert(node.expression);
}
case 'FunctionDeclaration':
case 'FunctionExpression': {
let name = null;
if (node.id) {
name = convert(node.id);
if (name == null) {
return null;
}
}
let params = convert(node.params);
if (!params) {
return null;
}
let body = convert(node.body);
if (!body) {
return null;
}
return builder.functionDeclaration(name, params, body);
}
case 'Identifier': {
return builder.identifier(node.name);
}
case 'Literal': {
return builder.literal(node.value);
}
case 'LogicalExpression': {
let left = convert(node.left);
if (!left) {
return null;
}
let right = convert(node.right);
if (!right) {
return null;
}
return builder.logicalExpression(left, node.operator, right);
}
case 'MemberExpression': {
let object = convert(node.object);
if (!object) {
return null;
}
let property = convert(node.property);
if (!property) {
return null;
}
return builder.memberExpression(object, property, node.computed);
}
case 'NewExpression': {
let callee = convert(node.callee);
if (!callee) {
return null;
}
let args = convert(node.arguments);
if (!args) {
return null;
}
return builder.newExpression(callee, args);
}
case 'Program': {
if (node.body && node.body.length === 1) {
return convert(node.body[0]);
}
return null;
}
case 'ObjectExpression': {
let properties = convert(node.properties);
if (!properties) {
return null;
}
return builder.objectExpression(properties);
}
case 'Property': {
let key = convert(node.key);
if (!key) {
return null;
}
let value = convert(node.value);
if (!value) {
return null;
}
return builder.property(key, value);
}
case 'ThisExpression': {
return builder.thisExpression();
}
case 'UnaryExpression': {
let argument = convert(node.argument);
if (!argument) {
return null;
}
return builder.unaryExpression(argument, node.operator, node.prefix);
}
default:
return null;
}
}
let jsAST;
try {
jsAST = esprima.parse('(' + src + ')');
} catch(e) {
var errorIndex = e.index;
var errorMessage = e.toString();
if (errorIndex != null && errorIndex >= 0) {
var srcCharProps = charProps(src);
errorIndex--; // Account for extra paren added to start
let line = srcCharProps.lineAt(errorIndex)+1;
let column = srcCharProps.columnAt(errorIndex)+1;
errorMessage += ' [Line ' + line + ', Col: ' + column + ']';
}
var wrappedError = new Error('Invalid JavaScript expression: ' + src + ' - ' + errorMessage);
wrappedError.index = errorIndex;
wrappedError.src = src;
wrappedError.code = 'ERR_INVALID_JAVASCRIPT_EXPRESSION';
throw wrappedError;
}
var converted = convert(jsAST);
if (converted == null) {
converted = builder.expression(src);
}
return converted;
}
module.exports = parseExpression;

249
compiler/util/parseJavaScript.js Normal file
View File

@ -0,0 +1,249 @@
'use strict';
var ok = require('assert').ok;
var charProps = require('char-props');
const esprima = require('esprima');
function parseExpression(src, builder, isExpression) {
ok(typeof src === 'string', '"src" should be a string expression');
ok(builder, '"builder" is required');
function convert(node) {
if (Array.isArray(node)) {
let nodes = node;
for (let i=0; i<nodes.length; i++) {
var converted = convert(nodes[i]);
if (converted == null) {
return null;
}
nodes[i] = converted;
}
return nodes;
}
switch(node.type) {
case 'ArrayExpression': {
let elements = convert(node.elements);
if (!elements) {
return null;
}
return builder.arrayExpression(elements);
}
case 'AssignmentExpression': {
let left = convert(node.left);
if (!left) {
return null;
}
let right = convert(node.right);
if (!right) {
return null;
}
return builder.assignment(left, right, node.operator);
}
case 'BinaryExpression': {
let left = convert(node.left);
if (!left) {
return null;
}
let right = convert(node.right);
if (!right) {
return null;
}
return builder.binaryExpression(left, node.operator, right);
}
case 'CallExpression': {
let callee = convert(node.callee);
if (!callee) {
return null;
}
let args = convert(node.arguments);
if (!args) {
return null;
}
return builder.functionCall(callee, args);
}
case 'ConditionalExpression': {
let test = convert(node.test);
if (!test) {
return null;
}
let consequent = convert(node.consequent);
if (!consequent) {
return null;
}
let alternate = convert(node.alternate);
if (!alternate) {
return null;
}
return builder.conditionalExpression(test, consequent, alternate);
}
case 'ExpressionStatement': {
return convert(node.expression);
}
case 'FunctionDeclaration':
case 'FunctionExpression': {
let name = null;
if (node.id) {
name = convert(node.id);
if (name == null) {
return null;
}
}
let params = convert(node.params);
if (!params) {
return null;
}
let body = convert(node.body);
if (!body) {
return null;
}
return builder.functionDeclaration(name, params, body);
}
case 'Identifier': {
return builder.identifier(node.name);
}
case 'Literal': {
return builder.literal(node.value);
}
case 'LogicalExpression': {
let left = convert(node.left);
if (!left) {
return null;
}
let right = convert(node.right);
if (!right) {
return null;
}
return builder.logicalExpression(left, node.operator, right);
}
case 'MemberExpression': {
let object = convert(node.object);
if (!object) {
return null;
}
let property = convert(node.property);
if (!property) {
return null;
}
return builder.memberExpression(object, property, node.computed);
}
case 'NewExpression': {
let callee = convert(node.callee);
if (!callee) {
return null;
}
let args = convert(node.arguments);
if (!args) {
return null;
}
return builder.newExpression(callee, args);
}
case 'Program': {
if (node.body && node.body.length === 1) {
return convert(node.body[0]);
}
return null;
}
case 'ObjectExpression': {
let properties = convert(node.properties);
if (!properties) {
return null;
}
return builder.objectExpression(properties);
}
case 'Property': {
let key = convert(node.key);
if (!key) {
return null;
}
let value = convert(node.value);
if (!value) {
return null;
}
return builder.property(key, value);
}
case 'ThisExpression': {
return builder.thisExpression();
}
case 'UnaryExpression': {
let argument = convert(node.argument);
if (!argument) {
return null;
}
return builder.unaryExpression(argument, node.operator, node.prefix);
}
case 'UpdateExpression': {
let argument = convert(node.argument);
if (!argument) {
return null;
}
return builder.updateExpression(argument, node.operator, node.prefix);
}
default:
return null;
}
}
let jsAST;
try {
if (isExpression) {
src = '(' + src + ')';
}
jsAST = esprima.parse(src);
} catch(e) {
var errorIndex = e.index;
var errorMessage = e.toString();
if (errorIndex != null && errorIndex >= 0) {
var srcCharProps = charProps(src);
if (isExpression) {
errorIndex--; // Account for extra paren added to start
}
let line = srcCharProps.lineAt(errorIndex)+1;
let column = srcCharProps.columnAt(errorIndex)+1;
errorMessage += ' [Line ' + line + ', Col: ' + column + ']';
}
var wrappedError = new Error('Invalid JavaScript expression: ' + src + ' - ' + errorMessage);
wrappedError.index = errorIndex;
wrappedError.src = src;
wrappedError.code = 'ERR_INVALID_JAVASCRIPT_EXPRESSION';
throw wrappedError;
}
var converted = convert(jsAST);
if (converted == null) {
converted = builder.expression(src);
}
return converted;
}
module.exports = parseExpression;

5
compiler/util/parseStatement.js Normal file
View File

@ -0,0 +1,5 @@
var parseJavaScript = require('./parseJavaScript');
module.exports = function(src, builder) {
return parseJavaScript(src, builder, false /* isExpression */ );
};