Created
March 23, 2014 21:25
-
-
Save dalen/9730100 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /* parser generated by jison 0.4.13 */ | |
| /* | |
| 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 puppetdbquery = (function(){ | |
| var parser = {trace: function trace() { }, | |
| yy: {}, | |
| symbols_: {"error":2,"query":3,"expression":4,"EOF":5,"literal_expression":6,"MATCH":7,"NOMATCH":8,"ISEQUAL":9,"NOTEQUAL":10,"GREATERTHAN":11,"GREATEREQUAL":12,"LESSTHAN":13,"LESSEQUAL":14,"NOT":15,"AND":16,"OR":17,"LPAREN":18,"RPAREN":19,"resource_expression":20,"boolean":21,"string":22,"number":23,"BOOLEAN":24,"NUMBER":25,"STRING":26,"resource_type_title":27,"resource_parameters":28,"resource_exported":29,"ATAT":30,"LBRACK":31,"RBRACK":32,"resource_param_start":33,"resource_param_end":34,"LBRACE":35,"RBRACE":36,"$accept":0,"$end":1}, | |
| terminals_: {2:"error",5:"EOF",7:"MATCH",8:"NOMATCH",9:"ISEQUAL",10:"NOTEQUAL",11:"GREATERTHAN",12:"GREATEREQUAL",13:"LESSTHAN",14:"LESSEQUAL",15:"NOT",16:"AND",17:"OR",18:"LPAREN",19:"RPAREN",24:"BOOLEAN",25:"NUMBER",26:"STRING",30:"ATAT",31:"LBRACK",32:"RBRACK",35:"LBRACE",36:"RBRACE"}, | |
| productions_: [0,[3,2],[3,1],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,2],[4,3],[4,3],[4,3],[4,1],[6,1],[6,1],[6,1],[21,1],[23,1],[22,1],[20,1],[20,2],[20,2],[20,3],[29,1],[27,4],[27,5],[28,3],[33,1],[34,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]; | |
| break; | |
| case 2: return null; | |
| break; | |
| case 3: this.$ = comparisonOp("~", $$[$0-2], $$[$0]) | |
| break; | |
| case 4: this.$ = ["not", comparisonOp("~", $$[$0-2], $$[$0])] | |
| break; | |
| case 5: this.$ = comparisonOp("=", $$[$0-2], $$[$0]) | |
| break; | |
| case 6: this.$ = ["not", comparisonOp("=", $$[$0-2], $$[$0])] | |
| break; | |
| case 7: this.$ = comparisonOp(">", $$[$0-2], $$[$0]) | |
| break; | |
| case 8: this.$ = comparisonOp(">=", $$[$0-2], $$[$0]) | |
| break; | |
| case 9: this.$ = comparisonOp("<", $$[$0-2], $$[$0]) | |
| break; | |
| case 10: this.$ = comparisonOp("<=", $$[$0-2], $$[$0]) | |
| break; | |
| case 11: this.$ = ["not", $$[$0]] | |
| break; | |
| case 12: this.$ = ["and", $$[$0-2], $$[$0]] | |
| break; | |
| case 13: this.$ = ["or", $$[$0-2], $$[$0]] | |
| break; | |
| case 14: this.$ = $$[$0-1] | |
| break; | |
| case 15: this.$ = ["in", "name", ["extract", "certname", ["select-resources", $$[$0] ]]] | |
| break; | |
| case 19: this.$ = yytext === 'true' ? true: false; | |
| break; | |
| case 20: this.$ = Number(yytext); | |
| break; | |
| case 21: this.$ = yytext; | |
| break; | |
| case 22: | |
| this.$ = $$[$0].concat([["=", "exported", false]]) | |
| break; | |
| case 23: | |
| this.$ = $$[$0-1].concat([["=", "exported", false], $$[$0]]) | |
| break; | |
| case 24: | |
| this.$ = $$[$0].concat([["=", "exported", true]]) | |
| break; | |
| case 25: | |
| this.$ = $$[$0-1].concat([["=", "exported", true], $$[$0]]) | |
| break; | |
| case 27: | |
| this.$ = ["and", | |
| ["=", "type", capitalize($$[$0-3]) ], | |
| ["=", "title", $$[$0-3].toLowerCase() === "class" ? capitalizeClass($$[$0-1]) : $$[$0-1]] | |
| ] | |
| break; | |
| case 28: | |
| this.$ = ["and", | |
| ["=", "type", capitalize($$[$0-4]) ], | |
| ["~", "title", $$[$0-4].toLowerCase() === "class" ? capitalizeClass($$[$0-1]) : $$[$0-1] ] | |
| ] | |
| break; | |
| case 29: this.$ = $$[$0-1] | |
| break; | |
| case 30: inResource = true; | |
| break; | |
| case 31: inResource = false; | |
| break; | |
| } | |
| }, | |
| table: [{3:1,4:2,5:[1,3],6:4,15:[1,5],18:[1,6],20:7,21:8,22:9,23:10,24:[1,13],25:[1,15],26:[1,14],27:11,29:12,30:[1,16]},{1:[3]},{5:[1,17],16:[1,18],17:[1,19]},{1:[2,2]},{7:[1,20],8:[1,21],9:[1,22],10:[1,23],11:[1,24],12:[1,25],13:[1,26],14:[1,27]},{4:28,6:4,15:[1,5],18:[1,6],20:7,21:8,22:9,23:10,24:[1,13],25:[1,15],26:[1,14],27:11,29:12,30:[1,16]},{4:29,6:4,15:[1,5],18:[1,6],20:7,21:8,22:9,23:10,24:[1,13],25:[1,15],26:[1,14],27:11,29:12,30:[1,16]},{5:[2,15],16:[2,15],17:[2,15],19:[2,15],36:[2,15]},{5:[2,16],7:[2,16],8:[2,16],9:[2,16],10:[2,16],11:[2,16],12:[2,16],13:[2,16],14:[2,16],16:[2,16],17:[2,16],19:[2,16],36:[2,16]},{7:[2,17],8:[2,17],9:[2,17],10:[2,17],11:[2,17],12:[2,17],13:[2,17],14:[2,17],31:[1,30]},{5:[2,18],7:[2,18],8:[2,18],9:[2,18],10:[2,18],11:[2,18],12:[2,18],13:[2,18],14:[2,18],16:[2,18],17:[2,18],19:[2,18],36:[2,18]},{5:[2,22],16:[2,22],17:[2,22],19:[2,22],28:31,33:32,35:[1,33],36:[2,22]},{22:35,26:[1,14],27:34},{5:[2,19],7:[2,19],8:[2,19],9:[2,19],10:[2,19],11:[2,19],12:[2,19],13:[2,19],14:[2,19],16:[2,19],17:[2,19],19:[2,19],36:[2,19]},{5:[2,21],7:[2,21],8:[2,21],9:[2,21],10:[2,21],11:[2,21],12:[2,21],13:[2,21],14:[2,21],16:[2,21],17:[2,21],19:[2,21],31:[2,21],32:[2,21],36:[2,21]},{5:[2,20],7:[2,20],8:[2,20],9:[2,20],10:[2,20],11:[2,20],12:[2,20],13:[2,20],14:[2,20],16:[2,20],17:[2,20],19:[2,20],36:[2,20]},{26:[2,26]},{1:[2,1]},{4:36,6:4,15:[1,5],18:[1,6],20:7,21:8,22:9,23:10,24:[1,13],25:[1,15],26:[1,14],27:11,29:12,30:[1,16]},{4:37,6:4,15:[1,5],18:[1,6],20:7,21:8,22:9,23:10,24:[1,13],25:[1,15],26:[1,14],27:11,29:12,30:[1,16]},{6:38,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{6:40,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{6:41,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{6:42,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{6:43,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{6:44,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{6:45,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{6:46,21:8,22:39,23:10,24:[1,13],25:[1,15],26:[1,14]},{5:[2,11],16:[1,18],17:[1,19],19:[2,11],36:[2,11]},{16:[1,18],17:[1,19],19:[1,47]},{7:[1,49],22:48,26:[1,14]},{5:[2,23],16:[2,23],17:[2,23],19:[2,23],36:[2,23]},{4:50,6:4,15:[1,5],18:[1,6],20:7,21:8,22:9,23:10,24:[1,13],25:[1,15],26:[1,14],27:11,29:12,30:[1,16]},{15:[2,30],18:[2,30],24:[2,30],25:[2,30],26:[2,30],30:[2,30]},{5:[2,24],16:[2,24],17:[2,24],19:[2,24],28:51,33:32,35:[1,33],36:[2,24]},{31:[1,30]},{5:[2,12],16:[2,12],17:[1,19],19:[2,12],36:[2,12]},{5:[2,13],16:[2,13],17:[2,13],19:[2,13],36:[2,13]},{5:[2,3],16:[2,3],17:[2,3],19:[2,3],36:[2,3]},{5:[2,17],16:[2,17],17:[2,17],19:[2,17],36:[2,17]},{5:[2,4],16:[2,4],17:[2,4],19:[2,4],36:[2,4]},{5:[2,5],16:[2,5],17:[2,5],19:[2,5],36:[2,5]},{5:[2,6],16:[2,6],17:[2,6],19:[2,6],36:[2,6]},{5:[2,7],16:[2,7],17:[2,7],19:[2,7],36:[2,7]},{5:[2,8],16:[2,8],17:[2,8],19:[2,8],36:[2,8]},{5:[2,9],16:[2,9],17:[2,9],19:[2,9],36:[2,9]},{5:[2,10],16:[2,10],17:[2,10],19:[2,10],36:[2,10]},{5:[2,14],16:[2,14],17:[2,14],19:[2,14],36:[2,14]},{32:[1,52]},{22:53,26:[1,14]},{16:[1,18],17:[1,19],34:54,36:[1,55]},{5:[2,25],16:[2,25],17:[2,25],19:[2,25],36:[2,25]},{5:[2,27],16:[2,27],17:[2,27],19:[2,27],35:[2,27],36:[2,27]},{32:[1,56]},{5:[2,29],16:[2,29],17:[2,29],19:[2,29],36:[2,29]},{5:[2,31],16:[2,31],17:[2,31],19:[2,31],36:[2,31]},{5:[2,28],16:[2,28],17:[2,28],19:[2,28],35:[2,28],36:[2,28]}], | |
| defaultActions: {3:[2,2],16:[2,26],17:[2,1]}, | |
| parseError: function parseError(str, hash) { | |
| if (hash.recoverable) { | |
| this.trace(str); | |
| } else { | |
| throw new Error(str); | |
| } | |
| }, | |
| parse: function parse(input) { | |
| var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1; | |
| var args = lstack.slice.call(arguments, 1); | |
| this.lexer.setInput(input); | |
| this.lexer.yy = this.yy; | |
| this.yy.lexer = this.lexer; | |
| this.yy.parser = this; | |
| if (typeof this.lexer.yylloc == 'undefined') { | |
| this.lexer.yylloc = {}; | |
| } | |
| var yyloc = this.lexer.yylloc; | |
| lstack.push(yyloc); | |
| var ranges = this.lexer.options && this.lexer.options.ranges; | |
| if (typeof this.yy.parseError === 'function') { | |
| this.parseError = this.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; | |
| } | |
| function lex() { | |
| var token; | |
| token = self.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 (this.lexer.showPosition) { | |
| errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + this.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: this.lexer.match, | |
| token: this.terminals_[symbol] || symbol, | |
| line: this.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(this.lexer.yytext); | |
| lstack.push(this.lexer.yylloc); | |
| stack.push(action[1]); | |
| symbol = null; | |
| if (!preErrorSymbol) { | |
| yyleng = this.lexer.yyleng; | |
| yytext = this.lexer.yytext; | |
| yylineno = this.lexer.yylineno; | |
| yyloc = this.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, | |
| this.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; | |
| }}; | |
| var inResource = false; | |
| function capitalize(s){ | |
| return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase(); | |
| } | |
| function capitalizeClass(s){ | |
| return s.split("::").map(function(part){ return capitalize(part); }).join("::"); | |
| } | |
| function comparisonOp(op, left, right){ | |
| if (inResource) { | |
| return [op, ["parameter", left], right]; | |
| } else { | |
| return [op, ["fact", left], right]; | |
| } | |
| } | |
| /* generated by jison-lex 0.2.1 */ | |
| 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) { | |
| 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 - 1); | |
| //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: /* whitespace no action */ | |
| break; | |
| case 1: return 18; | |
| break; | |
| case 2: return 19; | |
| break; | |
| case 3: return 31; | |
| break; | |
| case 4: return 32; | |
| break; | |
| case 5: return 35; | |
| break; | |
| case 6: return 36; | |
| break; | |
| case 7: return 9; | |
| break; | |
| case 8: return 10; | |
| break; | |
| case 9: return 7; | |
| break; | |
| case 10: return 13; | |
| break; | |
| case 11: return 14; | |
| break; | |
| case 12: return 11; | |
| break; | |
| case 13: return 12; | |
| break; | |
| case 14: return 15; | |
| break; | |
| case 15: return 16; | |
| break; | |
| case 16: return 17; | |
| break; | |
| case 17: return 24; | |
| break; | |
| case 18: return 24; | |
| break; | |
| case 19: return 25; | |
| break; | |
| case 20: yy_.yytext = eval(yy_.yytext); return 26; | |
| break; | |
| case 21: yy_.yytext = eval(yy_.yytext); return 26; | |
| break; | |
| case 22: return 26; | |
| break; | |
| case 23: return 30; | |
| break; | |
| case 24: return 5; | |
| break; | |
| } | |
| }, | |
| rules: [/^(?:\s+)/,/^(?:\()/,/^(?:\))/,/^(?:\[)/,/^(?:\])/,/^(?:\{)/,/^(?:\})/,/^(?:=)/,/^(?:!=)/,/^(?:~)/,/^(?:<)/,/^(?:<=)/,/^(?:>)/,/^(?:>=)/,/^(?:not\b)/,/^(?:and\b)/,/^(?:or\b)/,/^(?:true\b)/,/^(?:false\b)/,/^(?:-?\d+(\.\d+)?)/,/^(?:"(\\.|[^\\"])*")/,/^(?:'(\\.|[^\\'])*')/,/^(?:[\w_:]+)/,/^(?:@@)/,/^(?:$)/], | |
| 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],"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 = puppetdbquery; | |
| exports.Parser = puppetdbquery.Parser; | |
| exports.parse = function () { return puppetdbquery.parse.apply(puppetdbquery, 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)); | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment