605 lines
18 KiB
JavaScript
605 lines
18 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.OnlineParser = exports.RuleKind = exports.TokenKind = void 0;
|
|
|
|
var _lexer = require("../lexer.js");
|
|
|
|
var _source = require("../source.js");
|
|
|
|
var _grammar = _interopRequireDefault(require("./grammar.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var TokenKind = {
|
|
NAME: 'Name',
|
|
INT: 'Int',
|
|
FLOAT: 'Float',
|
|
STRING: 'String',
|
|
BLOCK_STRING: 'BlockString',
|
|
COMMENT: 'Comment',
|
|
PUNCTUATION: 'Punctuation',
|
|
EOF: '<EOF>',
|
|
INVALID: 'Invalid'
|
|
};
|
|
exports.TokenKind = TokenKind;
|
|
var RuleKind = {
|
|
TOKEN_CONSTRAINT: 'TokenConstraint',
|
|
OF_TYPE_CONSTRAINT: 'OfTypeConstraint',
|
|
LIST_OF_TYPE_CONSTRAINT: 'ListOfTypeConstraint',
|
|
PEEK_CONSTRAINT: 'PeekConstraint',
|
|
CONSTRAINTS_SET: 'ConstraintsSet',
|
|
CONSTRAINTS_SET_ROOT: 'ConstraintsSetRoot',
|
|
RULE_NAME: 'RuleName',
|
|
INVALID: 'Invalid'
|
|
};
|
|
exports.RuleKind = RuleKind;
|
|
|
|
var OnlineParser = /*#__PURE__*/function () {
|
|
function OnlineParser(source, state, config) {
|
|
var _config$tabSize;
|
|
|
|
this.state = state || OnlineParser.startState();
|
|
this._config = {
|
|
tabSize: (_config$tabSize = config === null || config === void 0 ? void 0 : config.tabSize) !== null && _config$tabSize !== void 0 ? _config$tabSize : 2
|
|
};
|
|
this._lexer = new _lexer.Lexer(new _source.Source(source));
|
|
}
|
|
|
|
OnlineParser.startState = function startState() {
|
|
return {
|
|
rules: [// $FlowFixMe[cannot-spread-interface]
|
|
_objectSpread(_objectSpread({
|
|
name: 'Document',
|
|
state: 'Document',
|
|
kind: 'ListOfTypeConstraint'
|
|
}, _grammar.default.Document), {}, {
|
|
expanded: false,
|
|
depth: 1,
|
|
step: 1
|
|
})],
|
|
name: null,
|
|
type: null,
|
|
levels: [],
|
|
indentLevel: 0,
|
|
kind: function kind() {
|
|
var _this$rules;
|
|
|
|
return ((_this$rules = this.rules[this.rules.length - 1]) === null || _this$rules === void 0 ? void 0 : _this$rules.state) || '';
|
|
},
|
|
step: function step() {
|
|
var _this$rules2;
|
|
|
|
return ((_this$rules2 = this.rules[this.rules.length - 1]) === null || _this$rules2 === void 0 ? void 0 : _this$rules2.step) || 0;
|
|
}
|
|
};
|
|
};
|
|
|
|
OnlineParser.copyState = function copyState(state) {
|
|
return {
|
|
name: state.name,
|
|
type: state.type,
|
|
rules: JSON.parse(JSON.stringify(state.rules)),
|
|
levels: [].concat(state.levels),
|
|
indentLevel: state.indentLevel,
|
|
kind: function kind() {
|
|
var _this$rules3;
|
|
|
|
return ((_this$rules3 = this.rules[this.rules.length - 1]) === null || _this$rules3 === void 0 ? void 0 : _this$rules3.state) || '';
|
|
},
|
|
step: function step() {
|
|
var _this$rules4;
|
|
|
|
return ((_this$rules4 = this.rules[this.rules.length - 1]) === null || _this$rules4 === void 0 ? void 0 : _this$rules4.step) || 0;
|
|
}
|
|
};
|
|
};
|
|
|
|
var _proto = OnlineParser.prototype;
|
|
|
|
_proto.sol = function sol() {
|
|
return this._lexer.source.locationOffset.line === 1 && this._lexer.source.locationOffset.column === 1;
|
|
};
|
|
|
|
_proto.parseToken = function parseToken() {
|
|
var rule = this._getNextRule();
|
|
|
|
if (this.sol()) {
|
|
this.state.indentLevel = Math.floor(this.indentation() / this._config.tabSize);
|
|
}
|
|
|
|
if (!rule) {
|
|
return {
|
|
kind: TokenKind.INVALID,
|
|
value: ''
|
|
};
|
|
}
|
|
|
|
var token;
|
|
|
|
if (this._lookAhead().kind === '<EOF>') {
|
|
return {
|
|
kind: TokenKind.EOF,
|
|
value: '',
|
|
ruleName: rule.name
|
|
};
|
|
}
|
|
|
|
switch (rule.kind) {
|
|
case RuleKind.TOKEN_CONSTRAINT:
|
|
token = this._parseTokenConstraint(rule);
|
|
break;
|
|
|
|
case RuleKind.LIST_OF_TYPE_CONSTRAINT:
|
|
token = this._parseListOfTypeConstraint(rule);
|
|
break;
|
|
|
|
case RuleKind.OF_TYPE_CONSTRAINT:
|
|
token = this._parseOfTypeConstraint(rule);
|
|
break;
|
|
|
|
case RuleKind.PEEK_CONSTRAINT:
|
|
token = this._parsePeekConstraint(rule);
|
|
break;
|
|
|
|
case RuleKind.CONSTRAINTS_SET_ROOT:
|
|
token = this._parseConstraintsSetRule(rule);
|
|
break;
|
|
|
|
default:
|
|
return {
|
|
kind: TokenKind.INVALID,
|
|
value: '',
|
|
ruleName: rule.name
|
|
};
|
|
}
|
|
|
|
if (token && token.kind === TokenKind.INVALID) {
|
|
if (rule.optional === true) {
|
|
this.state.rules.pop();
|
|
} else {
|
|
this._rollbackRule();
|
|
}
|
|
|
|
return this.parseToken() || token;
|
|
}
|
|
|
|
return token;
|
|
};
|
|
|
|
_proto.indentation = function indentation() {
|
|
var match = this._lexer.source.body.match(/\s*/);
|
|
|
|
var indent = 0;
|
|
|
|
if (match && match.length === 0) {
|
|
var whiteSpaces = match[0];
|
|
var pos = 0;
|
|
|
|
while (whiteSpaces.length > pos) {
|
|
if (whiteSpaces.charCodeAt(pos) === 9) {
|
|
indent += 2;
|
|
} else {
|
|
indent++;
|
|
}
|
|
|
|
pos++;
|
|
}
|
|
}
|
|
|
|
return indent;
|
|
};
|
|
|
|
_proto._parseTokenConstraint = function _parseTokenConstraint(rule) {
|
|
rule.expanded = true;
|
|
|
|
var token = this._lookAhead();
|
|
|
|
if (!this._matchToken(token, rule)) {
|
|
return {
|
|
kind: TokenKind.INVALID,
|
|
value: '',
|
|
tokenName: rule.tokenName,
|
|
ruleName: rule.name
|
|
};
|
|
}
|
|
|
|
this._advanceToken();
|
|
|
|
var parserToken = this._transformLexerToken(token, rule);
|
|
|
|
this._popMatchedRule(parserToken);
|
|
|
|
return parserToken;
|
|
};
|
|
|
|
_proto._parseListOfTypeConstraint = function _parseListOfTypeConstraint(rule) {
|
|
this._pushRule(_grammar.default[rule.listOfType], rule.depth + 1, rule.listOfType, 1, rule.state);
|
|
|
|
rule.expanded = true;
|
|
var token = this.parseToken();
|
|
return token;
|
|
};
|
|
|
|
_proto._parseOfTypeConstraint = function _parseOfTypeConstraint(rule) {
|
|
if (rule.expanded) {
|
|
this._popMatchedRule();
|
|
|
|
return this.parseToken();
|
|
}
|
|
|
|
this._pushRule(rule.ofType, rule.depth + 1, rule.tokenName, 1, rule.state);
|
|
|
|
rule.expanded = true;
|
|
var token = this.parseToken();
|
|
return token;
|
|
};
|
|
|
|
_proto._parsePeekConstraint = function _parsePeekConstraint(rule) {
|
|
if (rule.expanded) {
|
|
this._popMatchedRule();
|
|
|
|
return this.parseToken();
|
|
}
|
|
|
|
while (!rule.matched && rule.index < rule.peek.length - 1) {
|
|
rule.index++;
|
|
var constraint = rule.peek[rule.index];
|
|
var ifCondition = constraint.ifCondition;
|
|
|
|
if (typeof ifCondition === 'string') {
|
|
ifCondition = _grammar.default[ifCondition];
|
|
}
|
|
|
|
var token = this._lookAhead();
|
|
|
|
if (ifCondition && this._matchToken(token, ifCondition)) {
|
|
rule.matched = true;
|
|
rule.expanded = true;
|
|
|
|
this._pushRule(constraint.expect, rule.depth + 1, '', 1, rule.state);
|
|
|
|
token = this.parseToken();
|
|
return token;
|
|
}
|
|
}
|
|
|
|
return {
|
|
kind: TokenKind.INVALID,
|
|
value: '',
|
|
ruleName: rule.name
|
|
};
|
|
};
|
|
|
|
_proto._parseConstraintsSetRule = function _parseConstraintsSetRule(rule) {
|
|
if (rule.expanded) {
|
|
this._popMatchedRule();
|
|
|
|
return this.parseToken();
|
|
}
|
|
|
|
for (var index = rule.constraints.length - 1; index >= 0; index--) {
|
|
this._pushRule(rule.constraints[index], rule.depth + 1, '', index, rule.state);
|
|
}
|
|
|
|
rule.expanded = true;
|
|
return this.parseToken();
|
|
};
|
|
|
|
_proto._matchToken = function _matchToken(token, rule) {
|
|
if (typeof token.value === 'string') {
|
|
if (typeof rule.ofValue === 'string' && token.value !== rule.ofValue || Array.isArray(rule.oneOf) && !rule.oneOf.includes(token.value) || typeof rule.ofValue !== 'string' && !Array.isArray(rule.oneOf) && token.kind !== rule.token) {
|
|
return false;
|
|
}
|
|
|
|
return this._butNot(token, rule);
|
|
}
|
|
|
|
if (token.kind !== rule.token) {
|
|
return false;
|
|
}
|
|
|
|
return this._butNot(token, rule);
|
|
};
|
|
|
|
_proto._butNot = function _butNot(token, rule) {
|
|
var _this = this;
|
|
|
|
if (rule.butNot) {
|
|
if (Array.isArray(rule.butNot)) {
|
|
if (rule.butNot.reduce(function (matched, constraint) {
|
|
return matched || _this._matchToken(token, constraint);
|
|
}, false)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return !this._matchToken(token, rule.butNot);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
_proto._transformLexerToken = function _transformLexerToken(lexerToken, rule) {
|
|
var token;
|
|
var ruleName = rule.name || '';
|
|
var tokenName = rule.tokenName || '';
|
|
|
|
if (lexerToken.kind === '<EOF>' || lexerToken.value !== undefined) {
|
|
token = {
|
|
kind: lexerToken.kind,
|
|
value: lexerToken.value || '',
|
|
tokenName: tokenName,
|
|
ruleName: ruleName
|
|
};
|
|
|
|
if (token.kind === TokenKind.STRING) {
|
|
token.value = "\"".concat(token.value, "\"");
|
|
} else if (token.kind === TokenKind.BLOCK_STRING) {
|
|
token.value = "\"\"\"".concat(token.value, "\"\"\"");
|
|
}
|
|
} else {
|
|
token = {
|
|
kind: TokenKind.PUNCTUATION,
|
|
value: lexerToken.kind,
|
|
tokenName: tokenName,
|
|
ruleName: ruleName
|
|
};
|
|
|
|
if (/^[{([]/.test(token.value)) {
|
|
if (this.state.indentLevel !== undefined) {
|
|
this.state.levels = this.state.levels.concat(this.state.indentLevel + 1);
|
|
}
|
|
} else if (/^[})\]]/.test(token.value)) {
|
|
this.state.levels.pop();
|
|
}
|
|
}
|
|
|
|
return token;
|
|
};
|
|
|
|
_proto._getNextRule = function _getNextRule() {
|
|
return this.state.rules[this.state.rules.length - 1] || null;
|
|
};
|
|
|
|
_proto._popMatchedRule = function _popMatchedRule(token) {
|
|
var rule = this.state.rules.pop();
|
|
|
|
if (!rule) {
|
|
return;
|
|
}
|
|
|
|
if (token && rule.kind === RuleKind.TOKEN_CONSTRAINT) {
|
|
var constraint = rule;
|
|
|
|
if (typeof constraint.definitionName === 'string') {
|
|
this.state.name = token.value || null;
|
|
} else if (typeof constraint.typeName === 'string') {
|
|
this.state.type = token.value || null;
|
|
}
|
|
}
|
|
|
|
var nextRule = this._getNextRule();
|
|
|
|
if (!nextRule) {
|
|
return;
|
|
}
|
|
|
|
if (nextRule.depth === rule.depth - 1 && nextRule.expanded && nextRule.kind === RuleKind.CONSTRAINTS_SET_ROOT) {
|
|
this.state.rules.pop();
|
|
}
|
|
|
|
if (nextRule.depth === rule.depth - 1 && nextRule.expanded && nextRule.kind === RuleKind.LIST_OF_TYPE_CONSTRAINT) {
|
|
nextRule.expanded = false;
|
|
nextRule.optional = true;
|
|
}
|
|
};
|
|
|
|
_proto._rollbackRule = function _rollbackRule() {
|
|
var _this2 = this;
|
|
|
|
if (!this.state.rules.length) {
|
|
return;
|
|
}
|
|
|
|
var popRule = function popRule() {
|
|
var lastPoppedRule = _this2.state.rules.pop();
|
|
|
|
if (lastPoppedRule.eatNextOnFail === true) {
|
|
_this2.state.rules.pop();
|
|
}
|
|
};
|
|
|
|
var poppedRule = this.state.rules.pop();
|
|
|
|
if (!poppedRule) {
|
|
return;
|
|
}
|
|
|
|
var popped = 0;
|
|
|
|
var nextRule = this._getNextRule();
|
|
|
|
while (nextRule && (poppedRule.kind !== RuleKind.LIST_OF_TYPE_CONSTRAINT || nextRule.expanded) && nextRule.depth > poppedRule.depth - 1) {
|
|
this.state.rules.pop();
|
|
popped++;
|
|
nextRule = this._getNextRule();
|
|
}
|
|
|
|
if (nextRule && nextRule.expanded) {
|
|
if (nextRule.optional === true) {
|
|
popRule();
|
|
} else {
|
|
if (nextRule.kind === RuleKind.LIST_OF_TYPE_CONSTRAINT && popped === 1) {
|
|
this.state.rules.pop();
|
|
return;
|
|
}
|
|
|
|
this._rollbackRule();
|
|
}
|
|
}
|
|
};
|
|
|
|
_proto._pushRule = function _pushRule(baseRule, depth, name, step, state) {
|
|
var _this$_getNextRule, _this$_getNextRule2, _this$_getNextRule3, _this$_getNextRule4, _this$_getNextRule5, _this$_getNextRule6, _this$_getNextRule7, _this$_getNextRule8, _this$_getNextRule9, _this$_getNextRule10;
|
|
|
|
this.state.name = null;
|
|
this.state.type = null;
|
|
var rule = baseRule;
|
|
|
|
switch (this._getRuleKind(rule)) {
|
|
case RuleKind.RULE_NAME:
|
|
rule = rule;
|
|
|
|
this._pushRule(_grammar.default[rule], depth, (typeof name === 'string' ? name : undefined) || rule, step, state);
|
|
|
|
break;
|
|
|
|
case RuleKind.CONSTRAINTS_SET:
|
|
rule = rule;
|
|
this.state.rules.push({
|
|
name: name || '',
|
|
depth: depth,
|
|
expanded: false,
|
|
constraints: rule,
|
|
constraintsSet: true,
|
|
kind: RuleKind.CONSTRAINTS_SET_ROOT,
|
|
state: (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule = this._getNextRule()) === null || _this$_getNextRule === void 0 ? void 0 : _this$_getNextRule.state) || '',
|
|
step: typeof step === 'number' ? step : (((_this$_getNextRule2 = this._getNextRule()) === null || _this$_getNextRule2 === void 0 ? void 0 : _this$_getNextRule2.step) || 0) + 1
|
|
});
|
|
break;
|
|
|
|
case RuleKind.OF_TYPE_CONSTRAINT:
|
|
rule = rule;
|
|
this.state.rules.push({
|
|
name: name || '',
|
|
ofType: rule.ofType,
|
|
optional: Boolean(rule.optional),
|
|
butNot: rule.butNot,
|
|
eatNextOnFail: Boolean(rule.eatNextOnFail),
|
|
depth: depth,
|
|
expanded: false,
|
|
kind: RuleKind.OF_TYPE_CONSTRAINT,
|
|
state: (typeof rule.tokenName === 'string' ? rule.tokenName : undefined) || (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule3 = this._getNextRule()) === null || _this$_getNextRule3 === void 0 ? void 0 : _this$_getNextRule3.state) || '',
|
|
step: typeof step === 'number' ? step : (((_this$_getNextRule4 = this._getNextRule()) === null || _this$_getNextRule4 === void 0 ? void 0 : _this$_getNextRule4.step) || 0) + 1
|
|
});
|
|
break;
|
|
|
|
case RuleKind.LIST_OF_TYPE_CONSTRAINT:
|
|
rule = rule;
|
|
this.state.rules.push({
|
|
listOfType: rule.listOfType,
|
|
optional: Boolean(rule.optional),
|
|
butNot: rule.butNot,
|
|
eatNextOnFail: Boolean(rule.eatNextOnFail),
|
|
name: name || '',
|
|
depth: depth,
|
|
expanded: false,
|
|
kind: RuleKind.LIST_OF_TYPE_CONSTRAINT,
|
|
state: (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule5 = this._getNextRule()) === null || _this$_getNextRule5 === void 0 ? void 0 : _this$_getNextRule5.state) || '',
|
|
step: typeof step === 'number' ? step : (((_this$_getNextRule6 = this._getNextRule()) === null || _this$_getNextRule6 === void 0 ? void 0 : _this$_getNextRule6.step) || 0) + 1
|
|
});
|
|
break;
|
|
|
|
case RuleKind.TOKEN_CONSTRAINT:
|
|
rule = rule;
|
|
this.state.rules.push({
|
|
token: rule.token,
|
|
ofValue: rule.ofValue,
|
|
oneOf: rule.oneOf,
|
|
definitionName: Boolean(rule.definitionName),
|
|
typeName: Boolean(rule.typeName),
|
|
optional: Boolean(rule.optional),
|
|
butNot: rule.butNot,
|
|
eatNextOnFail: Boolean(rule.eatNextOnFail),
|
|
name: name || '',
|
|
depth: depth,
|
|
expanded: false,
|
|
kind: RuleKind.TOKEN_CONSTRAINT,
|
|
state: (typeof rule.tokenName === 'string' ? rule.tokenName : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule7 = this._getNextRule()) === null || _this$_getNextRule7 === void 0 ? void 0 : _this$_getNextRule7.state) || '',
|
|
step: typeof step === 'number' ? step : (((_this$_getNextRule8 = this._getNextRule()) === null || _this$_getNextRule8 === void 0 ? void 0 : _this$_getNextRule8.step) || 0) + 1
|
|
});
|
|
break;
|
|
|
|
case RuleKind.PEEK_CONSTRAINT:
|
|
rule = rule;
|
|
this.state.rules.push({
|
|
peek: rule.peek,
|
|
optional: Boolean(rule.optional),
|
|
butNot: rule.butNot,
|
|
eatNextOnFail: Boolean(rule.eatNextOnFail),
|
|
name: name || '',
|
|
depth: depth,
|
|
index: -1,
|
|
matched: false,
|
|
expanded: false,
|
|
kind: RuleKind.PEEK_CONSTRAINT,
|
|
state: (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule9 = this._getNextRule()) === null || _this$_getNextRule9 === void 0 ? void 0 : _this$_getNextRule9.state) || '',
|
|
step: typeof step === 'number' ? step : (((_this$_getNextRule10 = this._getNextRule()) === null || _this$_getNextRule10 === void 0 ? void 0 : _this$_getNextRule10.step) || 0) + 1
|
|
});
|
|
break;
|
|
}
|
|
};
|
|
|
|
_proto._getRuleKind = function _getRuleKind(rule) {
|
|
if (Array.isArray(rule)) {
|
|
return RuleKind.CONSTRAINTS_SET;
|
|
}
|
|
|
|
if (rule.constraintsSet === true) {
|
|
return RuleKind.CONSTRAINTS_SET_ROOT;
|
|
}
|
|
|
|
if (typeof rule === 'string') {
|
|
return RuleKind.RULE_NAME;
|
|
}
|
|
|
|
if (Object.prototype.hasOwnProperty.call(rule, 'ofType')) {
|
|
return RuleKind.OF_TYPE_CONSTRAINT;
|
|
}
|
|
|
|
if (Object.prototype.hasOwnProperty.call(rule, 'listOfType')) {
|
|
return RuleKind.LIST_OF_TYPE_CONSTRAINT;
|
|
}
|
|
|
|
if (Object.prototype.hasOwnProperty.call(rule, 'peek')) {
|
|
return RuleKind.PEEK_CONSTRAINT;
|
|
}
|
|
|
|
if (Object.prototype.hasOwnProperty.call(rule, 'token')) {
|
|
return RuleKind.TOKEN_CONSTRAINT;
|
|
}
|
|
|
|
return RuleKind.INVALID;
|
|
};
|
|
|
|
_proto._advanceToken = function _advanceToken() {
|
|
return this._lexer.advance();
|
|
};
|
|
|
|
_proto._lookAhead = function _lookAhead() {
|
|
try {
|
|
return this._lexer.lookahead();
|
|
} catch (err) {
|
|
return {
|
|
kind: TokenKind.INVALID,
|
|
value: ''
|
|
};
|
|
}
|
|
};
|
|
|
|
return OnlineParser;
|
|
}();
|
|
|
|
exports.OnlineParser = OnlineParser;
|