533 lines
11 KiB
JavaScript
533 lines
11 KiB
JavaScript
'use strict';
|
|
|
|
var use = require('use');
|
|
var util = require('util');
|
|
var Cache = require('map-cache');
|
|
var define = require('define-property');
|
|
var debug = require('debug')('snapdragon:parser');
|
|
var Position = require('./position');
|
|
var utils = require('./utils');
|
|
|
|
/**
|
|
* Create a new `Parser` with the given `input` and `options`.
|
|
* @param {String} `input`
|
|
* @param {Object} `options`
|
|
* @api public
|
|
*/
|
|
|
|
function Parser(options) {
|
|
debug('initializing', __filename);
|
|
this.options = utils.extend({source: 'string'}, options);
|
|
this.init(this.options);
|
|
use(this);
|
|
}
|
|
|
|
/**
|
|
* Prototype methods
|
|
*/
|
|
|
|
Parser.prototype = {
|
|
constructor: Parser,
|
|
|
|
init: function(options) {
|
|
this.orig = '';
|
|
this.input = '';
|
|
this.parsed = '';
|
|
|
|
this.column = 1;
|
|
this.line = 1;
|
|
|
|
this.regex = new Cache();
|
|
this.errors = this.errors || [];
|
|
this.parsers = this.parsers || {};
|
|
this.types = this.types || [];
|
|
this.sets = this.sets || {};
|
|
this.fns = this.fns || [];
|
|
this.currentType = 'root';
|
|
|
|
var pos = this.position();
|
|
this.bos = pos({type: 'bos', val: ''});
|
|
|
|
this.ast = {
|
|
type: 'root',
|
|
errors: this.errors,
|
|
nodes: [this.bos]
|
|
};
|
|
|
|
define(this.bos, 'parent', this.ast);
|
|
this.nodes = [this.ast];
|
|
|
|
this.count = 0;
|
|
this.setCount = 0;
|
|
this.stack = [];
|
|
},
|
|
|
|
/**
|
|
* Throw a formatted error with the cursor column and `msg`.
|
|
* @param {String} `msg` Message to use in the Error.
|
|
*/
|
|
|
|
error: function(msg, node) {
|
|
var pos = node.position || {start: {column: 0, line: 0}};
|
|
var line = pos.start.line;
|
|
var column = pos.start.column;
|
|
var source = this.options.source;
|
|
|
|
var message = source + ' <line:' + line + ' column:' + column + '>: ' + msg;
|
|
var err = new Error(message);
|
|
err.source = source;
|
|
err.reason = msg;
|
|
err.pos = pos;
|
|
|
|
if (this.options.silent) {
|
|
this.errors.push(err);
|
|
} else {
|
|
throw err;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Define a non-enumberable property on the `Parser` instance.
|
|
*
|
|
* ```js
|
|
* parser.define('foo', 'bar');
|
|
* ```
|
|
* @name .define
|
|
* @param {String} `key` propery name
|
|
* @param {any} `val` property value
|
|
* @return {Object} Returns the Parser instance for chaining.
|
|
* @api public
|
|
*/
|
|
|
|
define: function(key, val) {
|
|
define(this, key, val);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Mark position and patch `node.position`.
|
|
*/
|
|
|
|
position: function() {
|
|
var start = { line: this.line, column: this.column };
|
|
var self = this;
|
|
|
|
return function(node) {
|
|
define(node, 'position', new Position(start, self));
|
|
return node;
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Set parser `name` with the given `fn`
|
|
* @param {String} `name`
|
|
* @param {Function} `fn`
|
|
* @api public
|
|
*/
|
|
|
|
set: function(type, fn) {
|
|
if (this.types.indexOf(type) === -1) {
|
|
this.types.push(type);
|
|
}
|
|
this.parsers[type] = fn.bind(this);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Get parser `name`
|
|
* @param {String} `name`
|
|
* @api public
|
|
*/
|
|
|
|
get: function(name) {
|
|
return this.parsers[name];
|
|
},
|
|
|
|
/**
|
|
* Push a `token` onto the `type` stack.
|
|
*
|
|
* @param {String} `type`
|
|
* @return {Object} `token`
|
|
* @api public
|
|
*/
|
|
|
|
push: function(type, token) {
|
|
this.sets[type] = this.sets[type] || [];
|
|
this.count++;
|
|
this.stack.push(token);
|
|
return this.sets[type].push(token);
|
|
},
|
|
|
|
/**
|
|
* Pop a token off of the `type` stack
|
|
* @param {String} `type`
|
|
* @returns {Object} Returns a token
|
|
* @api public
|
|
*/
|
|
|
|
pop: function(type) {
|
|
this.sets[type] = this.sets[type] || [];
|
|
this.count--;
|
|
this.stack.pop();
|
|
return this.sets[type].pop();
|
|
},
|
|
|
|
/**
|
|
* Return true if inside a `stack` node. Types are `braces`, `parens` or `brackets`.
|
|
*
|
|
* @param {String} `type`
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
isInside: function(type) {
|
|
this.sets[type] = this.sets[type] || [];
|
|
return this.sets[type].length > 0;
|
|
},
|
|
|
|
/**
|
|
* Return true if `node` is the given `type`.
|
|
*
|
|
* ```js
|
|
* parser.isType(node, 'brace');
|
|
* ```
|
|
* @param {Object} `node`
|
|
* @param {String} `type`
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
isType: function(node, type) {
|
|
return node && node.type === type;
|
|
},
|
|
|
|
/**
|
|
* Get the previous AST node
|
|
* @return {Object}
|
|
*/
|
|
|
|
prev: function(n) {
|
|
return this.stack.length > 0
|
|
? utils.last(this.stack, n)
|
|
: utils.last(this.nodes, n);
|
|
},
|
|
|
|
/**
|
|
* Update line and column based on `str`.
|
|
*/
|
|
|
|
consume: function(len) {
|
|
this.input = this.input.substr(len);
|
|
},
|
|
|
|
/**
|
|
* Update column based on `str`.
|
|
*/
|
|
|
|
updatePosition: function(str, len) {
|
|
var lines = str.match(/\n/g);
|
|
if (lines) this.line += lines.length;
|
|
var i = str.lastIndexOf('\n');
|
|
this.column = ~i ? len - i : this.column + len;
|
|
this.parsed += str;
|
|
this.consume(len);
|
|
},
|
|
|
|
/**
|
|
* Match `regex`, return captures, and update the cursor position by `match[0]` length.
|
|
* @param {RegExp} `regex`
|
|
* @return {Object}
|
|
*/
|
|
|
|
match: function(regex) {
|
|
var m = regex.exec(this.input);
|
|
if (m) {
|
|
this.updatePosition(m[0], m[0].length);
|
|
return m;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Capture `type` with the given regex.
|
|
* @param {String} `type`
|
|
* @param {RegExp} `regex`
|
|
* @return {Function}
|
|
*/
|
|
|
|
capture: function(type, regex) {
|
|
if (typeof regex === 'function') {
|
|
return this.set.apply(this, arguments);
|
|
}
|
|
|
|
this.regex.set(type, regex);
|
|
this.set(type, function() {
|
|
var parsed = this.parsed;
|
|
var pos = this.position();
|
|
var m = this.match(regex);
|
|
if (!m || !m[0]) return;
|
|
|
|
var prev = this.prev();
|
|
var node = pos({
|
|
type: type,
|
|
val: m[0],
|
|
parsed: parsed,
|
|
rest: this.input
|
|
});
|
|
|
|
if (m[1]) {
|
|
node.inner = m[1];
|
|
}
|
|
|
|
define(node, 'inside', this.stack.length > 0);
|
|
define(node, 'parent', prev);
|
|
prev.nodes.push(node);
|
|
}.bind(this));
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Create a parser with open and close for parens,
|
|
* brackets or braces
|
|
*/
|
|
|
|
capturePair: function(type, openRegex, closeRegex, fn) {
|
|
this.sets[type] = this.sets[type] || [];
|
|
|
|
/**
|
|
* Open
|
|
*/
|
|
|
|
this.set(type + '.open', function() {
|
|
var parsed = this.parsed;
|
|
var pos = this.position();
|
|
var m = this.match(openRegex);
|
|
if (!m || !m[0]) return;
|
|
|
|
var val = m[0];
|
|
this.setCount++;
|
|
this.specialChars = true;
|
|
var open = pos({
|
|
type: type + '.open',
|
|
val: val,
|
|
rest: this.input
|
|
});
|
|
|
|
if (typeof m[1] !== 'undefined') {
|
|
open.inner = m[1];
|
|
}
|
|
|
|
var prev = this.prev();
|
|
var node = pos({
|
|
type: type,
|
|
nodes: [open]
|
|
});
|
|
|
|
define(node, 'rest', this.input);
|
|
define(node, 'parsed', parsed);
|
|
define(node, 'prefix', m[1]);
|
|
define(node, 'parent', prev);
|
|
define(open, 'parent', node);
|
|
|
|
if (typeof fn === 'function') {
|
|
fn.call(this, open, node);
|
|
}
|
|
|
|
this.push(type, node);
|
|
prev.nodes.push(node);
|
|
});
|
|
|
|
/**
|
|
* Close
|
|
*/
|
|
|
|
this.set(type + '.close', function() {
|
|
var pos = this.position();
|
|
var m = this.match(closeRegex);
|
|
if (!m || !m[0]) return;
|
|
|
|
var parent = this.pop(type);
|
|
var node = pos({
|
|
type: type + '.close',
|
|
rest: this.input,
|
|
suffix: m[1],
|
|
val: m[0]
|
|
});
|
|
|
|
if (!this.isType(parent, type)) {
|
|
if (this.options.strict) {
|
|
throw new Error('missing opening "' + type + '"');
|
|
}
|
|
|
|
this.setCount--;
|
|
node.escaped = true;
|
|
return node;
|
|
}
|
|
|
|
if (node.suffix === '\\') {
|
|
parent.escaped = true;
|
|
node.escaped = true;
|
|
}
|
|
|
|
parent.nodes.push(node);
|
|
define(node, 'parent', parent);
|
|
});
|
|
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Capture end-of-string
|
|
*/
|
|
|
|
eos: function() {
|
|
var pos = this.position();
|
|
if (this.input) return;
|
|
var prev = this.prev();
|
|
|
|
while (prev.type !== 'root' && !prev.visited) {
|
|
if (this.options.strict === true) {
|
|
throw new SyntaxError('invalid syntax:' + util.inspect(prev, null, 2));
|
|
}
|
|
|
|
if (!hasDelims(prev)) {
|
|
prev.parent.escaped = true;
|
|
prev.escaped = true;
|
|
}
|
|
|
|
visit(prev, function(node) {
|
|
if (!hasDelims(node.parent)) {
|
|
node.parent.escaped = true;
|
|
node.escaped = true;
|
|
}
|
|
});
|
|
|
|
prev = prev.parent;
|
|
}
|
|
|
|
var tok = pos({
|
|
type: 'eos',
|
|
val: this.append || ''
|
|
});
|
|
|
|
define(tok, 'parent', this.ast);
|
|
return tok;
|
|
},
|
|
|
|
/**
|
|
* Run parsers to advance the cursor position
|
|
*/
|
|
|
|
next: function() {
|
|
var parsed = this.parsed;
|
|
var len = this.types.length;
|
|
var idx = -1;
|
|
var tok;
|
|
|
|
while (++idx < len) {
|
|
if ((tok = this.parsers[this.types[idx]].call(this))) {
|
|
define(tok, 'rest', this.input);
|
|
define(tok, 'parsed', parsed);
|
|
this.last = tok;
|
|
return tok;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Parse the given string.
|
|
* @return {Array}
|
|
*/
|
|
|
|
parse: function(input) {
|
|
if (typeof input !== 'string') {
|
|
throw new TypeError('expected a string');
|
|
}
|
|
|
|
this.init(this.options);
|
|
this.orig = input;
|
|
this.input = input;
|
|
var self = this;
|
|
|
|
function parse() {
|
|
// check input before calling `.next()`
|
|
input = self.input;
|
|
|
|
// get the next AST ndoe
|
|
var node = self.next();
|
|
if (node) {
|
|
var prev = self.prev();
|
|
if (prev) {
|
|
define(node, 'parent', prev);
|
|
if (prev.nodes) {
|
|
prev.nodes.push(node);
|
|
}
|
|
}
|
|
|
|
if (self.sets.hasOwnProperty(prev.type)) {
|
|
self.currentType = prev.type;
|
|
}
|
|
}
|
|
|
|
// if we got here but input is not changed, throw an error
|
|
if (self.input && input === self.input) {
|
|
throw new Error('no parsers registered for: "' + self.input.slice(0, 5) + '"');
|
|
}
|
|
}
|
|
|
|
while (this.input) parse();
|
|
if (this.stack.length && this.options.strict) {
|
|
var node = this.stack.pop();
|
|
throw this.error('missing opening ' + node.type + ': "' + this.orig + '"');
|
|
}
|
|
|
|
var eos = this.eos();
|
|
var tok = this.prev();
|
|
if (tok.type !== 'eos') {
|
|
this.ast.nodes.push(eos);
|
|
}
|
|
|
|
return this.ast;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Visit `node` with the given `fn`
|
|
*/
|
|
|
|
function visit(node, fn) {
|
|
if (!node.visited) {
|
|
define(node, 'visited', true);
|
|
return node.nodes ? mapVisit(node.nodes, fn) : fn(node);
|
|
}
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Map visit over array of `nodes`.
|
|
*/
|
|
|
|
function mapVisit(nodes, fn) {
|
|
var len = nodes.length;
|
|
var idx = -1;
|
|
while (++idx < len) {
|
|
visit(nodes[idx], fn);
|
|
}
|
|
}
|
|
|
|
function hasOpen(node) {
|
|
return node.nodes && node.nodes[0].type === (node.type + '.open');
|
|
}
|
|
|
|
function hasClose(node) {
|
|
return node.nodes && utils.last(node.nodes).type === (node.type + '.close');
|
|
}
|
|
|
|
function hasDelims(node) {
|
|
return hasOpen(node) && hasClose(node);
|
|
}
|
|
|
|
/**
|
|
* Expose `Parser`
|
|
*/
|
|
|
|
module.exports = Parser;
|