1/* Jison generated parser */
  2var jsonlint = (function(){
  3var parser = {trace: function trace() { },
  4yy: {},
  5symbols_: {"error":2,"JSONString":3,"STRING":4,"JSONNumber":5,"NUMBER":6,"JSONNullLiteral":7,"NULL":8,"JSONBooleanLiteral":9,"TRUE":10,"FALSE":11,"JSONText":12,"JSONValue":13,"EOF":14,"JSONObject":15,"JSONArray":16,"{":17,"}":18,"JSONMemberList":19,"JSONMember":20,":":21,",":22,"[":23,"]":24,"JSONElementList":25,"$accept":0,"$end":1},
  6terminals_: {2:"error",4:"STRING",6:"NUMBER",8:"NULL",10:"TRUE",11:"FALSE",14:"EOF",17:"{",18:"}",21:":",22:",",23:"[",24:"]"},
  7productions_: [0,[3,1],[5,1],[7,1],[9,1],[9,1],[12,2],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[15,2],[15,3],[20,3],[19,1],[19,3],[16,2],[16,3],[25,1],[25,3]],
  8performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) {
  9
 10var $0 = $$.length - 1;
 11switch (yystate) {
 12case 1: // replace escaped characters with actual character
 13          this.$ = yytext.replace(/\\(\\|")/g, "$"+"1")
 14                     .replace(/\\n/g,'\n')
 15                     .replace(/\\r/g,'\r')
 16                     .replace(/\\t/g,'\t')
 17                     .replace(/\\v/g,'\v')
 18                     .replace(/\\f/g,'\f')
 19                     .replace(/\\b/g,'\b');
 20        
 21break;
 22case 2:this.$ = Number(yytext);
 23break;
 24case 3:this.$ = null;
 25break;
 26case 4:this.$ = true;
 27break;
 28case 5:this.$ = false;
 29break;
 30case 6:return this.$ = $$[$0-1];
 31break;
 32case 13:this.$ = {};
 33break;
 34case 14:this.$ = $$[$0-1];
 35break;
 36case 15:this.$ = [$$[$0-2], $$[$0]];
 37break;
 38case 16:this.$ = {}; this.$[$$[$0][0]] = $$[$0][1];
 39break;
 40case 17:this.$ = $$[$0-2]; $$[$0-2][$$[$0][0]] = $$[$0][1];
 41break;
 42case 18:this.$ = [];
 43break;
 44case 19:this.$ = $$[$0-1];
 45break;
 46case 20:this.$ = [$$[$0]];
 47break;
 48case 21:this.$ = $$[$0-2]; $$[$0-2].push($$[$0]);
 49break;
 50}
 51},
 52table: [{3:5,4:[1,12],5:6,6:[1,13],7:3,8:[1,9],9:4,10:[1,10],11:[1,11],12:1,13:2,15:7,16:8,17:[1,14],23:[1,15]},{1:[3]},{14:[1,16]},{14:[2,7],18:[2,7],22:[2,7],24:[2,7]},{14:[2,8],18:[2,8],22:[2,8],24:[2,8]},{14:[2,9],18:[2,9],22:[2,9],24:[2,9]},{14:[2,10],18:[2,10],22:[2,10],24:[2,10]},{14:[2,11],18:[2,11],22:[2,11],24:[2,11]},{14:[2,12],18:[2,12],22:[2,12],24:[2,12]},{14:[2,3],18:[2,3],22:[2,3],24:[2,3]},{14:[2,4],18:[2,4],22:[2,4],24:[2,4]},{14:[2,5],18:[2,5],22:[2,5],24:[2,5]},{14:[2,1],18:[2,1],21:[2,1],22:[2,1],24:[2,1]},{14:[2,2],18:[2,2],22:[2,2],24:[2,2]},{3:20,4:[1,12],18:[1,17],19:18,20:19},{3:5,4:[1,12],5:6,6:[1,13],7:3,8:[1,9],9:4,10:[1,10],11:[1,11],13:23,15:7,16:8,17:[1,14],23:[1,15],24:[1,21],25:22},{1:[2,6]},{14:[2,13],18:[2,13],22:[2,13],24:[2,13]},{18:[1,24],22:[1,25]},{18:[2,16],22:[2,16]},{21:[1,26]},{14:[2,18],18:[2,18],22:[2,18],24:[2,18]},{22:[1,28],24:[1,27]},{22:[2,20],24:[2,20]},{14:[2,14],18:[2,14],22:[2,14],24:[2,14]},{3:20,4:[1,12],20:29},{3:5,4:[1,12],5:6,6:[1,13],7:3,8:[1,9],9:4,10:[1,10],11:[1,11],13:30,15:7,16:8,17:[1,14],23:[1,15]},{14:[2,19],18:[2,19],22:[2,19],24:[2,19]},{3:5,4:[1,12],5:6,6:[1,13],7:3,8:[1,9],9:4,10:[1,10],11:[1,11],13:31,15:7,16:8,17:[1,14],23:[1,15]},{18:[2,17],22:[2,17]},{18:[2,15],22:[2,15]},{22:[2,21],24:[2,21]}],
 53defaultActions: {16:[2,6]},
 54parseError: function parseError(str, hash) {
 55    throw new Error(str);
 56},
 57parse: function parse(input) {
 58    var self = this,
 59        stack = [0],
 60        vstack = [null], // semantic value stack
 61        lstack = [], // location stack
 62        table = this.table,
 63        yytext = '',
 64        yylineno = 0,
 65        yyleng = 0,
 66        recovering = 0,
 67        TERROR = 2,
 68        EOF = 1;
 69
 70    //this.reductionCount = this.shiftCount = 0;
 71
 72    this.lexer.setInput(input);
 73    this.lexer.yy = this.yy;
 74    this.yy.lexer = this.lexer;
 75    if (typeof this.lexer.yylloc == 'undefined')
 76        this.lexer.yylloc = {};
 77    var yyloc = this.lexer.yylloc;
 78    lstack.push(yyloc);
 79
 80    if (typeof this.yy.parseError === 'function')
 81        this.parseError = this.yy.parseError;
 82
 83    function popStack (n) {
 84        stack.length = stack.length - 2*n;
 85        vstack.length = vstack.length - n;
 86        lstack.length = lstack.length - n;
 87    }
 88
 89    function lex() {
 90        var token;
 91        token = self.lexer.lex() || 1; // $end = 1
 92        // if token isn't its numeric value, convert
 93        if (typeof token !== 'number') {
 94            token = self.symbols_[token] || token;
 95        }
 96        return token;
 97    }
 98
 99    var symbol, preErrorSymbol, state, action, a, r, yyval={},p,len,newState, expected;
100    while (true) {
101        // retreive state number from top of stack
102        state = stack[stack.length-1];
103
104        // use default actions if available
105        if (this.defaultActions[state]) {
106            action = this.defaultActions[state];
107        } else {
108            if (symbol == null)
109                symbol = lex();
110            // read action for current state and first input
111            action = table[state] && table[state][symbol];
112        }
113
114        // handle parse error
115        _handle_error:
116        if (typeof action === 'undefined' || !action.length || !action[0]) {
117
118            if (!recovering) {
119                // Report error
120                expected = [];
121                for (p in table[state]) if (this.terminals_[p] && p > 2) {
122                    expected.push("'"+this.terminals_[p]+"'");
123                }
124                var errStr = '';
125                if (this.lexer.showPosition) {
126                    errStr = 'Parse error on line '+(yylineno+1)+":\n"+this.lexer.showPosition()+"\nExpecting "+expected.join(', ') + ", got '" + this.terminals_[symbol]+ "'";
127                } else {
128                    errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " +
129                                  (symbol == 1 /*EOF*/ ? "end of input" :
130                                              ("'"+(this.terminals_[symbol] || symbol)+"'"));
131                }
132                this.parseError(errStr,
133                    {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected});
134            }
135
136            // just recovered from another error
137            if (recovering == 3) {
138                if (symbol == EOF) {
139                    throw new Error(errStr || 'Parsing halted.');
140                }
141
142                // discard current lookahead and grab another
143                yyleng = this.lexer.yyleng;
144                yytext = this.lexer.yytext;
145                yylineno = this.lexer.yylineno;
146                yyloc = this.lexer.yylloc;
147                symbol = lex();
148            }
149
150            // try to recover from error
151            while (1) {
152                // check for error recovery rule in this state
153                if ((TERROR.toString()) in table[state]) {
154                    break;
155                }
156                if (state == 0) {
157                    throw new Error(errStr || 'Parsing halted.');
158                }
159                popStack(1);
160                state = stack[stack.length-1];
161            }
162
163            preErrorSymbol = symbol; // save the lookahead token
164            symbol = TERROR;         // insert generic error symbol as new lookahead
165            state = stack[stack.length-1];
166            action = table[state] && table[state][TERROR];
167            recovering = 3; // allow 3 real symbols to be shifted before reporting a new error
168        }
169
170        // this shouldn't happen, unless resolve defaults are off
171        if (action[0] instanceof Array && action.length > 1) {
172            throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol);
173        }
174
175        switch (action[0]) {
176
177            case 1: // shift
178                //this.shiftCount++;
179
180                stack.push(symbol);
181                vstack.push(this.lexer.yytext);
182                lstack.push(this.lexer.yylloc);
183                stack.push(action[1]); // push state
184                symbol = null;
185                if (!preErrorSymbol) { // normal execution/no error
186                    yyleng = this.lexer.yyleng;
187                    yytext = this.lexer.yytext;
188                    yylineno = this.lexer.yylineno;
189                    yyloc = this.lexer.yylloc;
190                    if (recovering > 0)
191                        recovering--;
192                } else { // error just occurred, resume old lookahead f/ before error
193                    symbol = preErrorSymbol;
194                    preErrorSymbol = null;
195                }
196                break;
197
198            case 2: // reduce
199                //this.reductionCount++;
200
201                len = this.productions_[action[1]][1];
202
203                // perform semantic action
204                yyval.$ = vstack[vstack.length-len]; // default to $$ = $1
205                // default location, uses first token for firsts, last for lasts
206                yyval._$ = {
207                    first_line: lstack[lstack.length-(len||1)].first_line,
208                    last_line: lstack[lstack.length-1].last_line,
209                    first_column: lstack[lstack.length-(len||1)].first_column,
210                    last_column: lstack[lstack.length-1].last_column
211                };
212                r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
213
214                if (typeof r !== 'undefined') {
215                    return r;
216                }
217
218                // pop off stack
219                if (len) {
220                    stack = stack.slice(0,-1*len*2);
221                    vstack = vstack.slice(0, -1*len);
222                    lstack = lstack.slice(0, -1*len);
223                }
224
225                stack.push(this.productions_[action[1]][0]);    // push nonterminal (reduce)
226                vstack.push(yyval.$);
227                lstack.push(yyval._$);
228                // goto new state = table[STATE][NONTERMINAL]
229                newState = table[stack[stack.length-2]][stack[stack.length-1]];
230                stack.push(newState);
231                break;
232
233            case 3: // accept
234                return true;
235        }
236
237    }
238
239    return true;
240}};
241/* Jison generated lexer */
242var lexer = (function(){
243var lexer = ({EOF:1,
244parseError:function parseError(str, hash) {
245        if (this.yy.parseError) {
246            this.yy.parseError(str, hash);
247        } else {
248            throw new Error(str);
249        }
250    },
251setInput:function (input) {
252        this._input = input;
253        this._more = this._less = this.done = false;
254        this.yylineno = this.yyleng = 0;
255        this.yytext = this.matched = this.match = '';
256        this.conditionStack = ['INITIAL'];
257        this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0};
258        return this;
259    },
260input:function () {
261        var ch = this._input[0];
262        this.yytext+=ch;
263        this.yyleng++;
264        this.match+=ch;
265        this.matched+=ch;
266        var lines = ch.match(/\n/);
267        if (lines) this.yylineno++;
268        this._input = this._input.slice(1);
269        return ch;
270    },
271unput:function (ch) {
272        this._input = ch + this._input;
273        return this;
274    },
275more:function () {
276        this._more = true;
277        return this;
278    },
279less:function (n) {
280        this._input = this.match.slice(n) + this._input;
281    },
282pastInput:function () {
283        var past = this.matched.substr(0, this.matched.length - this.match.length);
284        return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
285    },
286upcomingInput:function () {
287        var next = this.match;
288        if (next.length < 20) {
289            next += this._input.substr(0, 20-next.length);
290        }
291        return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, "");
292    },
293showPosition:function () {
294        var pre = this.pastInput();
295        var c = new Array(pre.length + 1).join("-");
296        return pre + this.upcomingInput() + "\n" + c+"^";
297    },
298next:function () {
299        if (this.done) {
300            return this.EOF;
301        }
302        if (!this._input) this.done = true;
303
304        var token,
305            match,
306            tempMatch,
307            index,
308            col,
309            lines;
310        if (!this._more) {
311            this.yytext = '';
312            this.match = '';
313        }
314        var rules = this._currentRules();
315        for (var i=0;i < rules.length; i++) {
316            tempMatch = this._input.match(this.rules[rules[i]]);
317            if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
318                match = tempMatch;
319                index = i;
320                if (!this.options.flex) break;
321            }
322        }
323        if (match) {
324            lines = match[0].match(/\n.*/g);
325            if (lines) this.yylineno += lines.length;
326            this.yylloc = {first_line: this.yylloc.last_line,
327                           last_line: this.yylineno+1,
328                           first_column: this.yylloc.last_column,
329                           last_column: lines ? lines[lines.length-1].length-1 : this.yylloc.last_column + match[0].length}
330            this.yytext += match[0];
331            this.match += match[0];
332            this.yyleng = this.yytext.length;
333            this._more = false;
334            this._input = this._input.slice(match[0].length);
335            this.matched += match[0];
336            token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]);
337            if (this.done && this._input) this.done = false;
338            if (token) return token;
339            else return;
340        }
341        if (this._input === "") {
342            return this.EOF;
343        } else {
344            this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), 
345                    {text: "", token: null, line: this.yylineno});
346        }
347    },
348lex:function lex() {
349        var r = this.next();
350        if (typeof r !== 'undefined') {
351            return r;
352        } else {
353            return this.lex();
354        }
355    },
356begin:function begin(condition) {
357        this.conditionStack.push(condition);
358    },
359popState:function popState() {
360        return this.conditionStack.pop();
361    },
362_currentRules:function _currentRules() {
363        return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules;
364    },
365topState:function () {
366        return this.conditionStack[this.conditionStack.length-2];
367    },
368pushState:function begin(condition) {
369        this.begin(condition);
370    }});
371lexer.options = {};
372lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
373
374var YYSTATE=YY_START
375switch($avoiding_name_collisions) {
376case 0:/* skip whitespace */
377break;
378case 1:return 6
379break;
380case 2:yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2); return 4
381break;
382case 3:return 17
383break;
384case 4:return 18
385break;
386case 5:return 23
387break;
388case 6:return 24
389break;
390case 7:return 22
391break;
392case 8:return 21
393break;
394case 9:return 10
395break;
396case 10:return 11
397break;
398case 11:return 8
399break;
400case 12:return 14
401break;
402case 13:return 'INVALID'
403break;
404}
405};
406lexer.rules = [/^(?:\s+)/,/^(?:(-?([0-9]|[1-9][0-9]+))(\.[0-9]+)?([eE][-+]?[0-9]+)?\b)/,/^(?:"(?:\\[\\"bfnrt/]|\\u[a-fA-F0-9]{4}|[^\\\0-\x09\x0a-\x1f"])*")/,/^(?:\{)/,/^(?:\})/,/^(?:\[)/,/^(?:\])/,/^(?:,)/,/^(?::)/,/^(?:true\b)/,/^(?:false\b)/,/^(?:null\b)/,/^(?:$)/,/^(?:.)/];
407lexer.conditions = {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13],"inclusive":true}};
408
409
410;
411return lexer;})()
412parser.lexer = lexer;
413return parser;
414})();
415if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
416exports.parser = jsonlint;
417exports.parse = function () { return jsonlint.parse.apply(jsonlint, arguments); }
418exports.main = function commonjsMain(args) {
419    if (!args[1])
420        throw new Error('Usage: '+args[0]+' FILE');
421    if (typeof process !== 'undefined') {
422        var source = require('fs').readFileSync(require('path').join(process.cwd(), args[1]), "utf8");
423    } else {
424        var cwd = require("file").path(require("file").cwd());
425        var source = cwd.join(args[1]).read({charset: "utf-8"});
426    }
427    return exports.parser.parse(source);
428}
429if (typeof module !== 'undefined' && require.main === module) {
430  exports.main(typeof process !== 'undefined' ? process.argv.slice(1) : require("system").args);
431}
432}