1
|
'use strict';
|
2
|
|
3
|
var use = require('use');
|
4
|
var util = require('util');
|
5
|
var Cache = require('map-cache');
|
6
|
var define = require('define-property');
|
7
|
var debug = require('debug')('snapdragon:parser');
|
8
|
var Position = require('./position');
|
9
|
var utils = require('./utils');
|
10
|
|
11
|
/**
|
12
|
* Create a new `Parser` with the given `input` and `options`.
|
13
|
* @param {String} `input`
|
14
|
* @param {Object} `options`
|
15
|
* @api public
|
16
|
*/
|
17
|
|
18
|
function Parser(options) {
|
19
|
debug('initializing', __filename);
|
20
|
this.options = utils.extend({source: 'string'}, options);
|
21
|
this.init(this.options);
|
22
|
use(this);
|
23
|
}
|
24
|
|
25
|
/**
|
26
|
* Prototype methods
|
27
|
*/
|
28
|
|
29
|
Parser.prototype = {
|
30
|
constructor: Parser,
|
31
|
|
32
|
init: function(options) {
|
33
|
this.orig = '';
|
34
|
this.input = '';
|
35
|
this.parsed = '';
|
36
|
|
37
|
this.column = 1;
|
38
|
this.line = 1;
|
39
|
|
40
|
this.regex = new Cache();
|
41
|
this.errors = this.errors || [];
|
42
|
this.parsers = this.parsers || {};
|
43
|
this.types = this.types || [];
|
44
|
this.sets = this.sets || {};
|
45
|
this.fns = this.fns || [];
|
46
|
this.currentType = 'root';
|
47
|
|
48
|
var pos = this.position();
|
49
|
this.bos = pos({type: 'bos', val: ''});
|
50
|
|
51
|
this.ast = {
|
52
|
type: 'root',
|
53
|
errors: this.errors,
|
54
|
nodes: [this.bos]
|
55
|
};
|
56
|
|
57
|
define(this.bos, 'parent', this.ast);
|
58
|
this.nodes = [this.ast];
|
59
|
|
60
|
this.count = 0;
|
61
|
this.setCount = 0;
|
62
|
this.stack = [];
|
63
|
},
|
64
|
|
65
|
/**
|
66
|
* Throw a formatted error with the cursor column and `msg`.
|
67
|
* @param {String} `msg` Message to use in the Error.
|
68
|
*/
|
69
|
|
70
|
error: function(msg, node) {
|
71
|
var pos = node.position || {start: {column: 0, line: 0}};
|
72
|
var line = pos.start.line;
|
73
|
var column = pos.start.column;
|
74
|
var source = this.options.source;
|
75
|
|
76
|
var message = source + ' <line:' + line + ' column:' + column + '>: ' + msg;
|
77
|
var err = new Error(message);
|
78
|
err.source = source;
|
79
|
err.reason = msg;
|
80
|
err.pos = pos;
|
81
|
|
82
|
if (this.options.silent) {
|
83
|
this.errors.push(err);
|
84
|
} else {
|
85
|
throw err;
|
86
|
}
|
87
|
},
|
88
|
|
89
|
/**
|
90
|
* Define a non-enumberable property on the `Parser` instance.
|
91
|
*
|
92
|
* ```js
|
93
|
* parser.define('foo', 'bar');
|
94
|
* ```
|
95
|
* @name .define
|
96
|
* @param {String} `key` propery name
|
97
|
* @param {any} `val` property value
|
98
|
* @return {Object} Returns the Parser instance for chaining.
|
99
|
* @api public
|
100
|
*/
|
101
|
|
102
|
define: function(key, val) {
|
103
|
define(this, key, val);
|
104
|
return this;
|
105
|
},
|
106
|
|
107
|
/**
|
108
|
* Mark position and patch `node.position`.
|
109
|
*/
|
110
|
|
111
|
position: function() {
|
112
|
var start = { line: this.line, column: this.column };
|
113
|
var self = this;
|
114
|
|
115
|
return function(node) {
|
116
|
define(node, 'position', new Position(start, self));
|
117
|
return node;
|
118
|
};
|
119
|
},
|
120
|
|
121
|
/**
|
122
|
* Set parser `name` with the given `fn`
|
123
|
* @param {String} `name`
|
124
|
* @param {Function} `fn`
|
125
|
* @api public
|
126
|
*/
|
127
|
|
128
|
set: function(type, fn) {
|
129
|
if (this.types.indexOf(type) === -1) {
|
130
|
this.types.push(type);
|
131
|
}
|
132
|
this.parsers[type] = fn.bind(this);
|
133
|
return this;
|
134
|
},
|
135
|
|
136
|
/**
|
137
|
* Get parser `name`
|
138
|
* @param {String} `name`
|
139
|
* @api public
|
140
|
*/
|
141
|
|
142
|
get: function(name) {
|
143
|
return this.parsers[name];
|
144
|
},
|
145
|
|
146
|
/**
|
147
|
* Push a `token` onto the `type` stack.
|
148
|
*
|
149
|
* @param {String} `type`
|
150
|
* @return {Object} `token`
|
151
|
* @api public
|
152
|
*/
|
153
|
|
154
|
push: function(type, token) {
|
155
|
this.sets[type] = this.sets[type] || [];
|
156
|
this.count++;
|
157
|
this.stack.push(token);
|
158
|
return this.sets[type].push(token);
|
159
|
},
|
160
|
|
161
|
/**
|
162
|
* Pop a token off of the `type` stack
|
163
|
* @param {String} `type`
|
164
|
* @returns {Object} Returns a token
|
165
|
* @api public
|
166
|
*/
|
167
|
|
168
|
pop: function(type) {
|
169
|
this.sets[type] = this.sets[type] || [];
|
170
|
this.count--;
|
171
|
this.stack.pop();
|
172
|
return this.sets[type].pop();
|
173
|
},
|
174
|
|
175
|
/**
|
176
|
* Return true if inside a `stack` node. Types are `braces`, `parens` or `brackets`.
|
177
|
*
|
178
|
* @param {String} `type`
|
179
|
* @return {Boolean}
|
180
|
* @api public
|
181
|
*/
|
182
|
|
183
|
isInside: function(type) {
|
184
|
this.sets[type] = this.sets[type] || [];
|
185
|
return this.sets[type].length > 0;
|
186
|
},
|
187
|
|
188
|
/**
|
189
|
* Return true if `node` is the given `type`.
|
190
|
*
|
191
|
* ```js
|
192
|
* parser.isType(node, 'brace');
|
193
|
* ```
|
194
|
* @param {Object} `node`
|
195
|
* @param {String} `type`
|
196
|
* @return {Boolean}
|
197
|
* @api public
|
198
|
*/
|
199
|
|
200
|
isType: function(node, type) {
|
201
|
return node && node.type === type;
|
202
|
},
|
203
|
|
204
|
/**
|
205
|
* Get the previous AST node
|
206
|
* @return {Object}
|
207
|
*/
|
208
|
|
209
|
prev: function(n) {
|
210
|
return this.stack.length > 0
|
211
|
? utils.last(this.stack, n)
|
212
|
: utils.last(this.nodes, n);
|
213
|
},
|
214
|
|
215
|
/**
|
216
|
* Update line and column based on `str`.
|
217
|
*/
|
218
|
|
219
|
consume: function(len) {
|
220
|
this.input = this.input.substr(len);
|
221
|
},
|
222
|
|
223
|
/**
|
224
|
* Update column based on `str`.
|
225
|
*/
|
226
|
|
227
|
updatePosition: function(str, len) {
|
228
|
var lines = str.match(/\n/g);
|
229
|
if (lines) this.line += lines.length;
|
230
|
var i = str.lastIndexOf('\n');
|
231
|
this.column = ~i ? len - i : this.column + len;
|
232
|
this.parsed += str;
|
233
|
this.consume(len);
|
234
|
},
|
235
|
|
236
|
/**
|
237
|
* Match `regex`, return captures, and update the cursor position by `match[0]` length.
|
238
|
* @param {RegExp} `regex`
|
239
|
* @return {Object}
|
240
|
*/
|
241
|
|
242
|
match: function(regex) {
|
243
|
var m = regex.exec(this.input);
|
244
|
if (m) {
|
245
|
this.updatePosition(m[0], m[0].length);
|
246
|
return m;
|
247
|
}
|
248
|
},
|
249
|
|
250
|
/**
|
251
|
* Capture `type` with the given regex.
|
252
|
* @param {String} `type`
|
253
|
* @param {RegExp} `regex`
|
254
|
* @return {Function}
|
255
|
*/
|
256
|
|
257
|
capture: function(type, regex) {
|
258
|
if (typeof regex === 'function') {
|
259
|
return this.set.apply(this, arguments);
|
260
|
}
|
261
|
|
262
|
this.regex.set(type, regex);
|
263
|
this.set(type, function() {
|
264
|
var parsed = this.parsed;
|
265
|
var pos = this.position();
|
266
|
var m = this.match(regex);
|
267
|
if (!m || !m[0]) return;
|
268
|
|
269
|
var prev = this.prev();
|
270
|
var node = pos({
|
271
|
type: type,
|
272
|
val: m[0],
|
273
|
parsed: parsed,
|
274
|
rest: this.input
|
275
|
});
|
276
|
|
277
|
if (m[1]) {
|
278
|
node.inner = m[1];
|
279
|
}
|
280
|
|
281
|
define(node, 'inside', this.stack.length > 0);
|
282
|
define(node, 'parent', prev);
|
283
|
prev.nodes.push(node);
|
284
|
}.bind(this));
|
285
|
return this;
|
286
|
},
|
287
|
|
288
|
/**
|
289
|
* Create a parser with open and close for parens,
|
290
|
* brackets or braces
|
291
|
*/
|
292
|
|
293
|
capturePair: function(type, openRegex, closeRegex, fn) {
|
294
|
this.sets[type] = this.sets[type] || [];
|
295
|
|
296
|
/**
|
297
|
* Open
|
298
|
*/
|
299
|
|
300
|
this.set(type + '.open', function() {
|
301
|
var parsed = this.parsed;
|
302
|
var pos = this.position();
|
303
|
var m = this.match(openRegex);
|
304
|
if (!m || !m[0]) return;
|
305
|
|
306
|
var val = m[0];
|
307
|
this.setCount++;
|
308
|
this.specialChars = true;
|
309
|
var open = pos({
|
310
|
type: type + '.open',
|
311
|
val: val,
|
312
|
rest: this.input
|
313
|
});
|
314
|
|
315
|
if (typeof m[1] !== 'undefined') {
|
316
|
open.inner = m[1];
|
317
|
}
|
318
|
|
319
|
var prev = this.prev();
|
320
|
var node = pos({
|
321
|
type: type,
|
322
|
nodes: [open]
|
323
|
});
|
324
|
|
325
|
define(node, 'rest', this.input);
|
326
|
define(node, 'parsed', parsed);
|
327
|
define(node, 'prefix', m[1]);
|
328
|
define(node, 'parent', prev);
|
329
|
define(open, 'parent', node);
|
330
|
|
331
|
if (typeof fn === 'function') {
|
332
|
fn.call(this, open, node);
|
333
|
}
|
334
|
|
335
|
this.push(type, node);
|
336
|
prev.nodes.push(node);
|
337
|
});
|
338
|
|
339
|
/**
|
340
|
* Close
|
341
|
*/
|
342
|
|
343
|
this.set(type + '.close', function() {
|
344
|
var pos = this.position();
|
345
|
var m = this.match(closeRegex);
|
346
|
if (!m || !m[0]) return;
|
347
|
|
348
|
var parent = this.pop(type);
|
349
|
var node = pos({
|
350
|
type: type + '.close',
|
351
|
rest: this.input,
|
352
|
suffix: m[1],
|
353
|
val: m[0]
|
354
|
});
|
355
|
|
356
|
if (!this.isType(parent, type)) {
|
357
|
if (this.options.strict) {
|
358
|
throw new Error('missing opening "' + type + '"');
|
359
|
}
|
360
|
|
361
|
this.setCount--;
|
362
|
node.escaped = true;
|
363
|
return node;
|
364
|
}
|
365
|
|
366
|
if (node.suffix === '\\') {
|
367
|
parent.escaped = true;
|
368
|
node.escaped = true;
|
369
|
}
|
370
|
|
371
|
parent.nodes.push(node);
|
372
|
define(node, 'parent', parent);
|
373
|
});
|
374
|
|
375
|
return this;
|
376
|
},
|
377
|
|
378
|
/**
|
379
|
* Capture end-of-string
|
380
|
*/
|
381
|
|
382
|
eos: function() {
|
383
|
var pos = this.position();
|
384
|
if (this.input) return;
|
385
|
var prev = this.prev();
|
386
|
|
387
|
while (prev.type !== 'root' && !prev.visited) {
|
388
|
if (this.options.strict === true) {
|
389
|
throw new SyntaxError('invalid syntax:' + util.inspect(prev, null, 2));
|
390
|
}
|
391
|
|
392
|
if (!hasDelims(prev)) {
|
393
|
prev.parent.escaped = true;
|
394
|
prev.escaped = true;
|
395
|
}
|
396
|
|
397
|
visit(prev, function(node) {
|
398
|
if (!hasDelims(node.parent)) {
|
399
|
node.parent.escaped = true;
|
400
|
node.escaped = true;
|
401
|
}
|
402
|
});
|
403
|
|
404
|
prev = prev.parent;
|
405
|
}
|
406
|
|
407
|
var tok = pos({
|
408
|
type: 'eos',
|
409
|
val: this.append || ''
|
410
|
});
|
411
|
|
412
|
define(tok, 'parent', this.ast);
|
413
|
return tok;
|
414
|
},
|
415
|
|
416
|
/**
|
417
|
* Run parsers to advance the cursor position
|
418
|
*/
|
419
|
|
420
|
next: function() {
|
421
|
var parsed = this.parsed;
|
422
|
var len = this.types.length;
|
423
|
var idx = -1;
|
424
|
var tok;
|
425
|
|
426
|
while (++idx < len) {
|
427
|
if ((tok = this.parsers[this.types[idx]].call(this))) {
|
428
|
define(tok, 'rest', this.input);
|
429
|
define(tok, 'parsed', parsed);
|
430
|
this.last = tok;
|
431
|
return tok;
|
432
|
}
|
433
|
}
|
434
|
},
|
435
|
|
436
|
/**
|
437
|
* Parse the given string.
|
438
|
* @return {Array}
|
439
|
*/
|
440
|
|
441
|
parse: function(input) {
|
442
|
if (typeof input !== 'string') {
|
443
|
throw new TypeError('expected a string');
|
444
|
}
|
445
|
|
446
|
this.init(this.options);
|
447
|
this.orig = input;
|
448
|
this.input = input;
|
449
|
var self = this;
|
450
|
|
451
|
function parse() {
|
452
|
// check input before calling `.next()`
|
453
|
input = self.input;
|
454
|
|
455
|
// get the next AST ndoe
|
456
|
var node = self.next();
|
457
|
if (node) {
|
458
|
var prev = self.prev();
|
459
|
if (prev) {
|
460
|
define(node, 'parent', prev);
|
461
|
if (prev.nodes) {
|
462
|
prev.nodes.push(node);
|
463
|
}
|
464
|
}
|
465
|
|
466
|
if (self.sets.hasOwnProperty(prev.type)) {
|
467
|
self.currentType = prev.type;
|
468
|
}
|
469
|
}
|
470
|
|
471
|
// if we got here but input is not changed, throw an error
|
472
|
if (self.input && input === self.input) {
|
473
|
throw new Error('no parsers registered for: "' + self.input.slice(0, 5) + '"');
|
474
|
}
|
475
|
}
|
476
|
|
477
|
while (this.input) parse();
|
478
|
if (this.stack.length && this.options.strict) {
|
479
|
var node = this.stack.pop();
|
480
|
throw this.error('missing opening ' + node.type + ': "' + this.orig + '"');
|
481
|
}
|
482
|
|
483
|
var eos = this.eos();
|
484
|
var tok = this.prev();
|
485
|
if (tok.type !== 'eos') {
|
486
|
this.ast.nodes.push(eos);
|
487
|
}
|
488
|
|
489
|
return this.ast;
|
490
|
}
|
491
|
};
|
492
|
|
493
|
/**
|
494
|
* Visit `node` with the given `fn`
|
495
|
*/
|
496
|
|
497
|
function visit(node, fn) {
|
498
|
if (!node.visited) {
|
499
|
define(node, 'visited', true);
|
500
|
return node.nodes ? mapVisit(node.nodes, fn) : fn(node);
|
501
|
}
|
502
|
return node;
|
503
|
}
|
504
|
|
505
|
/**
|
506
|
* Map visit over array of `nodes`.
|
507
|
*/
|
508
|
|
509
|
function mapVisit(nodes, fn) {
|
510
|
var len = nodes.length;
|
511
|
var idx = -1;
|
512
|
while (++idx < len) {
|
513
|
visit(nodes[idx], fn);
|
514
|
}
|
515
|
}
|
516
|
|
517
|
function hasOpen(node) {
|
518
|
return node.nodes && node.nodes[0].type === (node.type + '.open');
|
519
|
}
|
520
|
|
521
|
function hasClose(node) {
|
522
|
return node.nodes && utils.last(node.nodes).type === (node.type + '.close');
|
523
|
}
|
524
|
|
525
|
function hasDelims(node) {
|
526
|
return hasOpen(node) && hasClose(node);
|
527
|
}
|
528
|
|
529
|
/**
|
530
|
* Expose `Parser`
|
531
|
*/
|
532
|
|
533
|
module.exports = Parser;
|