diff --git a/.eslintignore b/.eslintignore index 1b38c48a..880d8107 100644 --- a/.eslintignore +++ b/.eslintignore @@ -1 +1,2 @@ src/serviceWorker.js +src/utils/pivotql/* diff --git a/src/modules/RA/DataLayer/components/SourceFilterField.js b/src/modules/RA/DataLayer/components/SourceFilterField.js index f9075005..bd2ef1cf 100644 --- a/src/modules/RA/DataLayer/components/SourceFilterField.js +++ b/src/modules/RA/DataLayer/components/SourceFilterField.js @@ -10,7 +10,7 @@ import debounce from 'lodash.debounce'; import searchService from '@terralego/core/modules/Visualizer/services/search'; -import parser from 'pivotql-parser-expression'; +// import parser from 'pivotql-parser-expression'; import compilerEs from 'pivotql-compiler-elasticsearch'; import TextField from '@material-ui/core/TextField'; @@ -26,6 +26,7 @@ import ListIcon from '@material-ui/icons/FormatListBulleted'; import FieldOption from './tabs/FieldOption'; import useSourceData from './useSourceData'; +import parser from '../../../../utils/pivotql'; const SourceFilterField = props => { diff --git a/src/utils/pivotql/index.js b/src/utils/pivotql/index.js new file mode 100644 index 00000000..0f042233 --- /dev/null +++ b/src/utils/pivotql/index.js @@ -0,0 +1,8 @@ +import parser from './parser.js'; + +export const parse = expression => { + const tree = parser.parse(expression); + return tree; +}; +export default parse; +//# sourceMappingURL=index.js.map diff --git a/src/utils/pivotql/index.js.map b/src/utils/pivotql/index.js.map new file mode 100644 index 00000000..3e9ccd70 --- /dev/null +++ b/src/utils/pivotql/index.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../src/index.js"],"names":["parser","parse","expression","tree"],"mappings":"AAAA,OAAOA,MAAP,MAAmB,aAAnB;AAEA,OAAO,MAAMC,KAAK,GAAIC,UAAD,IAAgB;AACnC,QAAMC,IAAI,GAAGH,MAAM,CAACC,KAAP,CAAaC,UAAb,CAAb;AACA,SAAOC,IAAP;AACD,CAHM;AAKP,eAAeF,KAAf","sourcesContent":["import parser from \"./parser.js\";\n\nexport const parse = (expression) => {\n const tree = parser.parse(expression);\n return tree;\n};\n\nexport default parse;\n"],"file":"index.js"} \ No newline at end of file diff --git a/src/utils/pivotql/package.json b/src/utils/pivotql/package.json new file mode 100644 index 00000000..47200257 --- /dev/null +++ b/src/utils/pivotql/package.json @@ -0,0 +1,3 @@ +{ + "type": "module" +} diff --git a/src/utils/pivotql/parser.js b/src/utils/pivotql/parser.js new file mode 100644 index 00000000..d34655e0 --- /dev/null +++ b/src/utils/pivotql/parser.js @@ -0,0 +1,1295 @@ +/* parser generated by jison 0.4.18 */ + +/* + Returns a Parser object of the following structure: + + Parser: { + yy: {} + } + + Parser.prototype: { + yy: {}, + trace: function(), + symbols_: {associative list: name ==> number}, + terminals_: {associative list: number ==> name}, + productions_: [...], + performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$), + table: [...], + defaultActions: {...}, + parseError: function(str, hash), + parse: function(input), + + lexer: { + EOF: 1, + parseError: function(str, hash), + setInput: function(input), + input: function(), + unput: function(str), + more: function(), + less: function(n), + pastInput: function(), + upcomingInput: function(), + showPosition: function(), + test_match: function(regex_match_array, rule_index), + next: function(), + lex: function(), + begin: function(condition), + popState: function(), + _currentRules: function(), + topState: function(), + pushState: function(condition), + + options: { + ranges: boolean (optional: true ==> token location info will include a .range[] member) + flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match) + backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code) + }, + + performAction: function(yy, yy_, $avoiding_name_collisions, YY_START), + rules: [...], + conditions: {associative list: name ==> set}, + } + } + + + token location info (@$, _$, etc.): { + first_line: n, + last_line: n, + first_column: n, + last_column: n, + range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based) + } + + + the parseError function receives a 'hash' object with these members for lexer and parser errors: { + text: (matched text) + token: (the produced terminal token, if any) + line: (yylineno) + } + while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: { + loc: (yylloc) + expected: (string describing the set of expected tokens) + recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error) + } +*/ +var parser = function () { + var o = function (k, v, o, l) { + for (o = o || {}, l = k.length; l--; o[k[l]] = v); + + return o; + }, + $V0 = [1, 9], + $V1 = [1, 10], + $V2 = [1, 11], + $V3 = [1, 12], + $V4 = [1, 13], + $V5 = [1, 8], + $V6 = [1, 3], + $V7 = [1, 4], + $V8 = [1, 5], + $V9 = [1, 15], + $Va = [1, 16], + $Vb = [1, 17], + $Vc = [1, 18], + $Vd = [1, 19], + $Ve = [1, 20], + $Vf = [1, 21], + $Vg = [1, 22], + $Vh = [1, 23], + $Vi = [1, 24], + $Vj = [5, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 30], + $Vk = [5, 14, 16, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 30], + $Vl = [14, 16], + $Vm = [5, 18, 19, 20, 22, 23, 30]; + + var parser = { + trace: function trace() {}, + yy: {}, + symbols_: { + error: 2, + expressions: 3, + e: 4, + EOF: 5, + VALUE: 6, + NUMBER: 7, + BOOLEAN: 8, + PRIMITIVE: 9, + STRING: 10, + SYMBOL: 11, + ARRAY: 12, + "[": 13, + "]": 14, + LIST: 15, + ",": 16, + "-": 17, + and: 18, + or: 19, + in: 20, + not: 21, + "==": 22, + "!=": 23, + "~=": 24, + "<=": 25, + ">=": 26, + "<": 27, + ">": 28, + "(": 29, + ")": 30, + $accept: 0, + $end: 1 + }, + terminals_: { + 2: "error", + 5: "EOF", + 7: "NUMBER", + 8: "BOOLEAN", + 9: "PRIMITIVE", + 10: "STRING", + 11: "SYMBOL", + 13: "[", + 14: "]", + 16: ",", + 17: "-", + 18: "and", + 19: "or", + 20: "in", + 21: "not", + 22: "==", + 23: "!=", + 24: "~=", + 25: "<=", + 26: ">=", + 27: "<", + 28: ">", + 29: "(", + 30: ")" + }, + productions_: [0, [3, 2], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [12, 2], [12, 3], [15, 1], [15, 3], [4, 2], [4, 3], [4, 3], [4, 3], [4, 2], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 1], [4, 1]], + performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate + /* action[1] */ + , $$ + /* vstack */ + , _$ + /* lstack */ + ) { + /* this == yyval */ + var $0 = $$.length - 1; + + switch (yystate) { + case 1: + return $$[$0 - 1].type === "SYMBOL" ? { ...$$[$0 - 1], + alone: true + } : $$[$0 - 1]; + break; + + case 2: + this.$ = { + type: "NUMBER", + value: $$[$0].includes(".") ? parseFloat($$[$0]) : parseInt($$[$0], 10) + }; + break; + + case 3: + this.$ = { + type: "BOOLEAN", + value: $$[$0] === "true" + }; + break; + + case 4: + this.$ = { + type: "PRIMITIVE", + value: $$[$0] === "null" ? null : undefined + }; + break; + + case 5: + this.$ = { + type: "STRING", + value: $$[$0] + }; + break; + + case 6: + this.$ = { + type: "SYMBOL", + value: $$[$0] + }; + break; + + case 7: + this.$ = { + type: "ARRAY", + children: [] + }; + break; + + case 8: + this.$ = { + type: "ARRAY", + children: $$[$0 - 1] + }; + break; + + case 9: + this.$ = [$$[$0]]; + break; + + case 10: + this.$ = $$[$0 - 2]; + $$[$0 - 2].push($$[$0]); + break; + + case 11: + this.$ = { + type: "-", + children: [$$[$0]] + }; + break; + + case 12: + this.$ = { + type: "&&", + children: [$$[$0 - 2].type === "SYMBOL" ? { ...$$[$0 - 2], + alone: true + } : $$[$0 - 2], $$[$0].type === "SYMBOL" ? { ...$$[$0], + alone: true + } : $$[$0]] + }; + break; + + case 13: + this.$ = { + type: "||", + children: [$$[$0 - 2].type === "SYMBOL" ? { ...$$[$0 - 2], + alone: true + } : $$[$0 - 2], $$[$0].type === "SYMBOL" ? { ...$$[$0], + alone: true + } : $$[$0]] + }; + break; + + case 14: + this.$ = { + type: "IN", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 15: + this.$ = { + type: "!", + children: [$$[$0].type === "SYMBOL" ? { ...$$[$0], + alone: true + } : $$[$0]] + }; + break; + + case 16: + this.$ = { + type: "==", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 17: + this.$ = { + type: "!=", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 18: + this.$ = { + type: "MATCH", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 19: + this.$ = { + type: "<=", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 20: + this.$ = { + type: ">=", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 21: + this.$ = { + type: "<", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 22: + this.$ = { + type: ">", + children: [$$[$0 - 2], $$[$0]] + }; + break; + + case 23: + this.$ = { + type: "EXPRESSION", + children: [$$[$0 - 1].type === "SYMBOL" ? { ...$$[$0 - 1], + alone: true + } : $$[$0 - 1]] + }; + break; + + case 24: + case 25: + this.$ = $$[$0]; + break; + } + }, + table: [{ + 3: 1, + 4: 2, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 1: [3] + }, { + 5: [1, 14], + 18: $V9, + 19: $Va, + 20: $Vb, + 22: $Vc, + 23: $Vd, + 24: $Ve, + 25: $Vf, + 26: $Vg, + 27: $Vh, + 28: $Vi + }, { + 4: 25, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 26, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 27, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, o($Vj, [2, 24]), o($Vj, [2, 25]), { + 6: 30, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 14: [1, 28], + 15: 29 + }, o($Vk, [2, 2]), o($Vk, [2, 3]), o($Vk, [2, 4]), o($Vk, [2, 5]), o($Vk, [2, 6]), { + 1: [2, 1] + }, { + 4: 31, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 32, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 33, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 34, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 35, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 36, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 37, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 38, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 39, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, { + 4: 40, + 6: 7, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4, + 12: 6, + 13: $V5, + 17: $V6, + 21: $V7, + 29: $V8 + }, o($Vj, [2, 11]), o($Vj, [2, 15]), { + 18: $V9, + 19: $Va, + 20: $Vb, + 22: $Vc, + 23: $Vd, + 24: $Ve, + 25: $Vf, + 26: $Vg, + 27: $Vh, + 28: $Vi, + 30: [1, 41] + }, o($Vj, [2, 7]), { + 14: [1, 42], + 16: [1, 43] + }, o($Vl, [2, 9]), o([5, 18, 19, 30], [2, 12], { + 20: $Vb, + 22: $Vc, + 23: $Vd, + 24: $Ve, + 25: $Vf, + 26: $Vg, + 27: $Vh, + 28: $Vi + }), o([5, 19, 30], [2, 13], { + 18: $V9, + 20: $Vb, + 22: $Vc, + 23: $Vd, + 24: $Ve, + 25: $Vf, + 26: $Vg, + 27: $Vh, + 28: $Vi + }), o([5, 18, 19, 20, 30], [2, 14], { + 22: $Vc, + 23: $Vd, + 24: $Ve, + 25: $Vf, + 26: $Vg, + 27: $Vh, + 28: $Vi + }), o($Vm, [2, 16], { + 24: $Ve, + 25: $Vf, + 26: $Vg, + 27: $Vh, + 28: $Vi + }), o($Vm, [2, 17], { + 24: $Ve, + 25: $Vf, + 26: $Vg, + 27: $Vh, + 28: $Vi + }), o($Vj, [2, 18]), o($Vj, [2, 19]), o($Vj, [2, 20]), o($Vj, [2, 21]), o($Vj, [2, 22]), o($Vj, [2, 23]), o($Vj, [2, 8]), { + 6: 44, + 7: $V0, + 8: $V1, + 9: $V2, + 10: $V3, + 11: $V4 + }, o($Vl, [2, 10])], + defaultActions: { + 14: [2, 1] + }, + parseError: function parseError(str, hash) { + if (hash.recoverable) { + this.trace(str); + } else { + var error = new Error(str); + error.hash = hash; + throw error; + } + }, + parse: function parse(input) { + var self = this, + stack = [0], + tstack = [], + vstack = [null], + lstack = [], + table = this.table, + yytext = "", + yylineno = 0, + yyleng = 0, + recovering = 0, + TERROR = 2, + EOF = 1; + var args = lstack.slice.call(arguments, 1); + var lexer = Object.create(this.lexer); + var sharedState = { + yy: {} + }; + + for (var k in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k)) { + sharedState.yy[k] = this.yy[k]; + } + } + + lexer.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer; + sharedState.yy.parser = this; + + if (typeof lexer.yylloc == "undefined") { + lexer.yylloc = {}; + } + + var yyloc = lexer.yylloc; + lstack.push(yyloc); + var ranges = lexer.options && lexer.options.ranges; + + if (typeof sharedState.yy.parseError === "function") { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + + function popStack(n) { + stack.length = stack.length - 2 * n; + vstack.length = vstack.length - n; + lstack.length = lstack.length - n; + } + + _token_stack: var lex = function () { + var token; + token = lexer.lex() || EOF; + + if (typeof token !== "number") { + token = self.symbols_[token] || token; + } + + return token; + }; + + var symbol, + preErrorSymbol, + state, + action, + a, + r, + yyval = {}, + p, + len, + newState, + expected; + + while (true) { + state = stack[stack.length - 1]; + + if (this.defaultActions[state]) { + action = this.defaultActions[state]; + } else { + if (symbol === null || typeof symbol == "undefined") { + symbol = lex(); + } + + action = table[state] && table[state][symbol]; + } + + if (typeof action === "undefined" || !action.length || !action[0]) { + var errStr = ""; + expected = []; + + for (p in table[state]) { + if (this.terminals_[p] && p > TERROR) { + expected.push("'" + this.terminals_[p] + "'"); + } + } + + if (lexer.showPosition) { + errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; + } else { + errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'"); + } + + this.parseError(errStr, { + text: lexer.match, + token: this.terminals_[symbol] || symbol, + line: lexer.yylineno, + loc: yyloc, + expected: expected + }); + } + + if (action[0] instanceof Array && action.length > 1) { + throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol); + } + + switch (action[0]) { + case 1: + stack.push(symbol); + vstack.push(lexer.yytext); + lstack.push(lexer.yylloc); + stack.push(action[1]); + symbol = null; + + if (!preErrorSymbol) { + yyleng = lexer.yyleng; + yytext = lexer.yytext; + yylineno = lexer.yylineno; + yyloc = lexer.yylloc; + + if (recovering > 0) { + recovering--; + } + } else { + symbol = preErrorSymbol; + preErrorSymbol = null; + } + + break; + + case 2: + len = this.productions_[action[1]][1]; + yyval.$ = vstack[vstack.length - len]; + yyval._$ = { + first_line: lstack[lstack.length - (len || 1)].first_line, + last_line: lstack[lstack.length - 1].last_line, + first_column: lstack[lstack.length - (len || 1)].first_column, + last_column: lstack[lstack.length - 1].last_column + }; + + if (ranges) { + yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]]; + } + + r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args)); + + if (typeof r !== "undefined") { + return r; + } + + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + + stack.push(this.productions_[action[1]][0]); + vstack.push(yyval.$); + lstack.push(yyval._$); + newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState); + break; + + case 3: + return true; + } + } + + return true; + } + }; + /* generated by jison-lex 0.3.4 */ + + var lexer = function () { + var lexer = { + EOF: 1, + parseError: function parseError(str, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str, hash); + } else { + throw new Error(str); + } + }, + // resets the lexer, sets new input + setInput: function (input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ""; + this.conditionStack = ["INITIAL"]; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + + if (this.options.ranges) { + this.yylloc.range = [0, 0]; + } + + this.offset = 0; + return this; + }, + // consumes and returns one char from the input + input: function () { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + + if (this.options.ranges) { + this.yylloc.range[1]++; + } + + this._input = this._input.slice(1); + return ch; + }, + // unshifts one char (or a string) into the input + unput: function (ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); //this.yyleng -= len; + + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + + var r = this.yylloc.range; + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len + }; + + if (this.options.ranges) { + this.yylloc.range = [r[0], r[0] + this.yyleng - len]; + } + + this.yyleng = this.yytext.length; + return this; + }, + // When called from action, caches matched text and appends it on next action + more: function () { + this._more = true; + return this; + }, + // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. + reject: function () { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + + return this; + }, + // retain first n characters of the match + less: function (n) { + this.unput(this.match.slice(n)); + }, + // displays already matched input, i.e. for error messages + pastInput: function () { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, ""); + }, + // displays upcoming input, i.e. for error messages + upcomingInput: function () { + var next = this.match; + + if (next.length < 20) { + next += this._input.substr(0, 20 - next.length); + } + + return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, ""); + }, + // displays the character position where the lexing error occurred, i.e. for error messages + showPosition: function () { + var pre = this.pastInput(); + var c = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c + "^"; + }, + // test the lexed token: return FALSE when not a match, otherwise return token + test_match: function (match, indexed_rule) { + var token, lines, backup; + + if (this.options.backtrack_lexer) { + // save context + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + + lines = match[0].match(/(?:\r\n?|\n).*/g); + + if (lines) { + this.yylineno += lines.length; + } + + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length + }; + this.yytext += match[0]; + this.match += match[0]; + this.matches = match; + this.yyleng = this.yytext.length; + + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match[0].length); + this.matched += match[0]; + token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + + if (this.done && this._input) { + this.done = false; + } + + if (token) { + return token; + } else if (this._backtrack) { + // recover context + for (var k in backup) { + this[k] = backup[k]; + } + + return false; // rule action called reject() implying the next rule should be tested instead. + } + + return false; + }, + // return next match in input + next: function () { + if (this.done) { + return this.EOF; + } + + if (!this._input) { + this.done = true; + } + + var token, match, tempMatch, index; + + if (!this._more) { + this.yytext = ""; + this.match = ""; + } + + var rules = this._currentRules(); + + for (var i = 0; i < rules.length; i++) { + tempMatch = this._input.match(this.rules[rules[i]]); + + if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { + match = tempMatch; + index = i; + + if (this.options.backtrack_lexer) { + token = this.test_match(tempMatch, rules[i]); + + if (token !== false) { + return token; + } else if (this._backtrack) { + match = false; + continue; // rule action called reject() implying a rule MISmatch. + } else { + // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + + if (match) { + token = this.test_match(match, rules[index]); + + if (token !== false) { + return token; + } // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + + + return false; + } + + if (this._input === "") { + return this.EOF; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, + // return next match that has a token + lex: function lex() { + var r = this.next(); + + if (r) { + return r; + } else { + return this.lex(); + } + }, + // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) + begin: function begin(condition) { + this.conditionStack.push(condition); + }, + // pop the previously active lexer condition state off the condition stack + popState: function popState() { + var n = this.conditionStack.length - 1; + + if (n > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, + // produce the lexer rule set which is active for the currently active lexer condition state + _currentRules: function _currentRules() { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, + // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available + topState: function topState(n) { + n = this.conditionStack.length - 1 - Math.abs(n || 0); + + if (n >= 0) { + return this.conditionStack[n]; + } else { + return "INITIAL"; + } + }, + // alias for begin(condition) + pushState: function pushState(condition) { + this.begin(condition); + }, + // return the number of states currently on the stack + stateStackSize: function stateStackSize() { + return this.conditionStack.length; + }, + options: {}, + performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { + var YYSTATE = YY_START; + + switch ($avoiding_name_collisions) { + case 0: + break; + + case 1: + return "("; + break; + + case 2: + return ")"; + break; + + case 3: + return "["; + break; + + case 4: + return "]"; + break; + + case 5: + return ","; + break; + + case 6: + return "=="; + break; + + case 7: + return "=="; + break; + + case 8: + return "!="; + break; + + case 9: + return "~="; + break; + + case 10: + return ">="; + break; + + case 11: + return "<="; + break; + + case 12: + return "<"; + break; + + case 13: + return ">"; + break; + + case 14: + return "and"; + break; + + case 15: + return "or"; + break; + + case 16: + return "not"; + break; + + case 17: + return "in"; + break; + + case 18: + return "NUMBER"; + break; + + case 19: + return "BOOLEAN"; + break; + + case 20: + return "PRIMITIVE"; + break; + + case 21: + return "SYMBOL"; + break; + + case 22: + yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); + return "STRING"; + break; + + case 23: + yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); + return "STRING"; + break; + + case 24: + return "-"; + break; + + case 25: + return "EOF"; + break; + } + }, + rules: [/^(?:\s+)/, /^(?:\()/, /^(?:\))/, /^(?:\[)/, /^(?:\])/, /^(?:,)/, /^(?:==)/, /^(?:=)/, /^(?:\!=)/, /^(?:~=)/, /^(?:>=)/, /^(?:<=)/, /^(?:<)/, /^(?:>)/, /^(?:and[^\w])/, /^(?:or[^\w])/, /^(?:not[^\w])/, /^(?:in[^\w])/, /^(?:-?[0-9]+(?:\.[0-9]+)?\b)/, /^(?:true|false)/, /^(?:null|undefined)/, /^(?:[A-zÀ-ÖØ-öø-įĴ-őŔ-žǍ-ǰǴ-ǵǸ-țȞ-ȟȤ-ȳɃɆ-ɏḀ-ẞƀ-ƓƗ-ƚƝ-ơƤ-ƥƫ-ưƲ-ƶẠ-ỿ_][\.A-zÀ-ÖØ-öø-įĴ-őŔ-žǍ-ǰǴ-ǵǸ-țȞ-ȟȤ-ȳɃɆ-ɏḀ-ẞƀ-ƓƗ-ƚƝ-ơƤ-ƥƫ-ưƲ-ƶẠ-ỿ_0-9-]*)/, /^(?:"(\[\"]|[^\"])*")/, /^(?:'(\[\']|[^\'])*')/, /^(?:-)/, /^(?:$)/], + conditions: { + INITIAL: { + rules: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], + inclusive: true + } + } + }; + return lexer; + }(); + + parser.lexer = lexer; + + function Parser() { + this.yy = {}; + } + + Parser.prototype = parser; + parser.Parser = Parser; + return new Parser(); +}(); + +if (typeof require !== "undefined" && typeof exports !== "undefined") { + exports.parser = parser; + exports.Parser = parser.Parser; + + exports.parse = function () { + return parser.parse.apply(parser, arguments); + }; + + exports.main = function commonjsMain(args) { + if (!args[1]) { + console.log("Usage: " + args[0] + " FILE"); + process.exit(1); + } + + var source = require("fs").readFileSync(require("path").normalize(args[1]), "utf8"); + + return exports.parser.parse(source); + }; + + if (typeof module !== "undefined" && require.main === module) { + exports.main(process.argv.slice(1)); + } +} + +export default parser; +//# sourceMappingURL=parser.js.map \ No newline at end of file