syntax-parser is a parser using pure javascript, so it can both run in browser and nodejs.
syntax-parser supports:
- lexer.
- parser.
createLexer can help you create a lexer.
import { createLexer } from 'syntax-parser';
const myLexer = createLexer([
{
type: 'whitespace',
regexes: [/^(\s+)/],
ignore: true
},
{
type: 'word',
regexes: [/^([a-zA-Z0-9]+)/]
},
{
type: 'operator',
regexes: [/^(\+)/]
}
]);
myLexer('a + b');
// [
// { "type": "word", "value": "a", "position": [0, 1] },
// { "type": "operator", "value": "+", "position": [2, 3] },
// { "type": "word", "value": "b", "position": [4, 5] }
// ]type
Token type name, you can use any value here, and you will use it in the parser stage.
regexes
Regexes that use to be matched for each Token type.
ignore
The matching Token will not be added to the Token result queue.
In general, whitespace can be ignored in syntax parsing.
createParser can help you create a parser. Parser requires a lexer.
import { createParser, chain, matchTokenType, many } from 'syntax-parser';
const root = () => chain(addExpr)(ast => ast[0]);
const addExpr = () =>
chain(matchTokenType('word'), many(addPlus))(ast => ({
left: ast[0].value,
operator: ast[1] && ast[1][0].operator,
right: ast[1] && ast[1][0].term
}));
const addPlus = () =>
chain('+', root)(ast => ({
operator: ast[0].value,
term: ast[1]
}));
const myParser = createParser(
root, // Root grammar.
myLexer // Created in lexer example.
);
myParser('a + b');
// ast:
// [{
// "left": "a",
// "operator": "+",
// "right": {
// "left": "b",
// "operator": null,
// "right": null
// }
// }]Basic grammatical element, support four parameters:
String means match token:
chain('select', 'table'); // Match 'select table'Array means 'or':
chain('select', ['table', 'chart']); // Match both 'select table' and 'select chart'matchTokenType allow you match Token type defined in lexer.
chain('select', matchTokenType('word')); // Match 'select [any word!]'It's easy to call another chain function:
const a = () => chain('select', b);
const b = () => chain('table');Just as literal meaning:
const a = () => chain('select', optional('table')); // Match both 'select' and 'select table'
const b = () => chain('select', many(',', matchTokenType('word'))); // Match both 'select' and 'select a' and 'select a, b' .. and so on.
optionalmanycan also usechainas parameter.many(chain(..))
The last callback allow partial redefin of local ast:
chain('select', 'table')(
ast => ast[0] // return 'select'
);npm test
If you want to see this demo, run this command:
npm run docsThen select demo Monaco Editor.