www.aleph1.co.uk Git - yaffs-website/blob - node_modules/spdx-expression-parse/parser.js

   1 /* parser generated by jison 0.4.17 */
   2 /*
   3   Returns a Parser object of the following structure:
   4
   5   Parser: {
   6     yy: {}
   7   }
   8
   9   Parser.prototype: {
  10     yy: {},
  11     trace: function(),
  12     symbols_: {associative list: name ==> number},
  13     terminals_: {associative list: number ==> name},
  14     productions_: [...],
  15     performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  16     table: [...],
  17     defaultActions: {...},
  18     parseError: function(str, hash),
  19     parse: function(input),
  20
  21     lexer: {
  22         EOF: 1,
  23         parseError: function(str, hash),
  24         setInput: function(input),
  25         input: function(),
  26         unput: function(str),
  27         more: function(),
  28         less: function(n),
  29         pastInput: function(),
  30         upcomingInput: function(),
  31         showPosition: function(),
  32         test_match: function(regex_match_array, rule_index),
  33         next: function(),
  34         lex: function(),
  35         begin: function(condition),
  36         popState: function(),
  37         _currentRules: function(),
  38         topState: function(),
  39         pushState: function(condition),
  40
  41         options: {
  42             ranges: boolean           (optional: true ==> token location info will include a .range[] member)
  43             flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
  44             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)
  45         },
  46
  47         performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
  48         rules: [...],
  49         conditions: {associative list: name ==> set},
  50     }
  51   }
  52
  53
  54   token location info (@$, _$, etc.): {
  55     first_line: n,
  56     last_line: n,
  57     first_column: n,
  58     last_column: n,
  59     range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
  60   }
  61
  62
  63   the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  64     text:        (matched text)
  65     token:       (the produced terminal token, if any)
  66     line:        (yylineno)
  67   }
  68   while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  69     loc:         (yylloc)
  70     expected:    (string describing the set of expected tokens)
  71     recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
  72   }
  73 */
  74 var spdxparse = (function(){
  75 var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,5],$V1=[1,6],$V2=[1,7],$V3=[1,4],$V4=[1,9],$V5=[1,10],$V6=[5,14,15,17],$V7=[5,12,14,15,17];
  76 var parser = {trace: function trace() { },
  77 yy: {},
  78 symbols_: {"error":2,"start":3,"expression":4,"EOS":5,"simpleExpression":6,"LICENSE":7,"PLUS":8,"LICENSEREF":9,"DOCUMENTREF":10,"COLON":11,"WITH":12,"EXCEPTION":13,"AND":14,"OR":15,"OPEN":16,"CLOSE":17,"$accept":0,"$end":1},
  79 terminals_: {2:"error",5:"EOS",7:"LICENSE",8:"PLUS",9:"LICENSEREF",10:"DOCUMENTREF",11:"COLON",12:"WITH",13:"EXCEPTION",14:"AND",15:"OR",16:"OPEN",17:"CLOSE"},
  80 productions_: [0,[3,2],[6,1],[6,2],[6,1],[6,3],[4,1],[4,3],[4,3],[4,3],[4,3]],
  81 performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
  82 /* this == yyval */
  83
  84 var $0 = $$.length - 1;
  85 switch (yystate) {
  86 case 1:
  87 return this.$ = $$[$0-1]
  88 break;
  89 case 2: case 4: case 5:
  90 this.$ = {license: yytext}
  91 break;
  92 case 3:
  93 this.$ = {license: $$[$0-1], plus: true}
  94 break;
  95 case 6:
  96 this.$ = $$[$0]
  97 break;
  98 case 7:
  99 this.$ = {exception: $$[$0]}
 100 this.$.license = $$[$0-2].license
 101 if ($$[$0-2].hasOwnProperty('plus')) {
 102   this.$.plus = $$[$0-2].plus
 103 }
 104 break;
 105 case 8:
 106 this.$ = {conjunction: 'and', left: $$[$0-2], right: $$[$0]}
 107 break;
 108 case 9:
 109 this.$ = {conjunction: 'or', left: $$[$0-2], right: $$[$0]}
 110 break;
 111 case 10:
 112 this.$ = $$[$0-1]
 113 break;
 114 }
 115 },
 116 table: [{3:1,4:2,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{1:[3]},{5:[1,8],14:$V4,15:$V5},o($V6,[2,6],{12:[1,11]}),{4:12,6:3,7:$V0,9:$V1,10:$V2,16:$V3},o($V7,[2,2],{8:[1,13]}),o($V7,[2,4]),{11:[1,14]},{1:[2,1]},{4:15,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{4:16,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{13:[1,17]},{14:$V4,15:$V5,17:[1,18]},o($V7,[2,3]),{9:[1,19]},o($V6,[2,8]),o([5,15,17],[2,9],{14:$V4}),o($V6,[2,7]),o($V6,[2,10]),o($V7,[2,5])],
 117 defaultActions: {8:[2,1]},
 118 parseError: function parseError(str, hash) {
 119     if (hash.recoverable) {
 120         this.trace(str);
 121     } else {
 122         function _parseError (msg, hash) {
 123             this.message = msg;
 124             this.hash = hash;
 125         }
 126         _parseError.prototype = Error;
 127
 128         throw new _parseError(str, hash);
 129     }
 130 },
 131 parse: function parse(input) {
 132     var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
 133     var args = lstack.slice.call(arguments, 1);
 134     var lexer = Object.create(this.lexer);
 135     var sharedState = { yy: {} };
 136     for (var k in this.yy) {
 137         if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
 138             sharedState.yy[k] = this.yy[k];
 139         }
 140     }
 141     lexer.setInput(input, sharedState.yy);
 142     sharedState.yy.lexer = lexer;
 143     sharedState.yy.parser = this;
 144     if (typeof lexer.yylloc == 'undefined') {
 145         lexer.yylloc = {};
 146     }
 147     var yyloc = lexer.yylloc;
 148     lstack.push(yyloc);
 149     var ranges = lexer.options && lexer.options.ranges;
 150     if (typeof sharedState.yy.parseError === 'function') {
 151         this.parseError = sharedState.yy.parseError;
 152     } else {
 153         this.parseError = Object.getPrototypeOf(this).parseError;
 154     }
 155     function popStack(n) {
 156         stack.length = stack.length - 2 * n;
 157         vstack.length = vstack.length - n;
 158         lstack.length = lstack.length - n;
 159     }
 160     _token_stack:
 161         var lex = function () {
 162             var token;
 163             token = lexer.lex() || EOF;
 164             if (typeof token !== 'number') {
 165                 token = self.symbols_[token] || token;
 166             }
 167             return token;
 168         };
 169     var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
 170     while (true) {
 171         state = stack[stack.length - 1];
 172         if (this.defaultActions[state]) {
 173             action = this.defaultActions[state];
 174         } else {
 175             if (symbol === null || typeof symbol == 'undefined') {
 176                 symbol = lex();
 177             }
 178             action = table[state] && table[state][symbol];
 179         }
 180                     if (typeof action === 'undefined' || !action.length || !action[0]) {
 181                 var errStr = '';
 182                 expected = [];
 183                 for (p in table[state]) {
 184                     if (this.terminals_[p] && p > TERROR) {
 185                         expected.push('\'' + this.terminals_[p] + '\'');
 186                     }
 187                 }
 188                 if (lexer.showPosition) {
 189                     errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
 190                 } else {
 191                     errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
 192                 }
 193                 this.parseError(errStr, {
 194                     text: lexer.match,
 195                     token: this.terminals_[symbol] || symbol,
 196                     line: lexer.yylineno,
 197                     loc: yyloc,
 198                     expected: expected
 199                 });
 200             }
 201         if (action[0] instanceof Array && action.length > 1) {
 202             throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
 203         }
 204         switch (action[0]) {
 205         case 1:
 206             stack.push(symbol);
 207             vstack.push(lexer.yytext);
 208             lstack.push(lexer.yylloc);
 209             stack.push(action[1]);
 210             symbol = null;
 211             if (!preErrorSymbol) {
 212                 yyleng = lexer.yyleng;
 213                 yytext = lexer.yytext;
 214                 yylineno = lexer.yylineno;
 215                 yyloc = lexer.yylloc;
 216                 if (recovering > 0) {
 217                     recovering--;
 218                 }
 219             } else {
 220                 symbol = preErrorSymbol;
 221                 preErrorSymbol = null;
 222             }
 223             break;
 224         case 2:
 225             len = this.productions_[action[1]][1];
 226             yyval.$ = vstack[vstack.length - len];
 227             yyval._$ = {
 228                 first_line: lstack[lstack.length - (len || 1)].first_line,
 229                 last_line: lstack[lstack.length - 1].last_line,
 230                 first_column: lstack[lstack.length - (len || 1)].first_column,
 231                 last_column: lstack[lstack.length - 1].last_column
 232             };
 233             if (ranges) {
 234                 yyval._$.range = [
 235                     lstack[lstack.length - (len || 1)].range[0],
 236                     lstack[lstack.length - 1].range[1]
 237                 ];
 238             }
 239             r = this.performAction.apply(yyval, [
 240                 yytext,
 241                 yyleng,
 242                 yylineno,
 243                 sharedState.yy,
 244                 action[1],
 245                 vstack,
 246                 lstack
 247             ].concat(args));
 248             if (typeof r !== 'undefined') {
 249                 return r;
 250             }
 251             if (len) {
 252                 stack = stack.slice(0, -1 * len * 2);
 253                 vstack = vstack.slice(0, -1 * len);
 254                 lstack = lstack.slice(0, -1 * len);
 255             }
 256             stack.push(this.productions_[action[1]][0]);
 257             vstack.push(yyval.$);
 258             lstack.push(yyval._$);
 259             newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
 260             stack.push(newState);
 261             break;
 262         case 3:
 263             return true;
 264         }
 265     }
 266     return true;
 267 }};
 268 /* generated by jison-lex 0.3.4 */
 269 var lexer = (function(){
 270 var lexer = ({
 271
 272 EOF:1,
 273
 274 parseError:function parseError(str, hash) {
 275         if (this.yy.parser) {
 276             this.yy.parser.parseError(str, hash);
 277         } else {
 278             throw new Error(str);
 279         }
 280     },
 281
 282 // resets the lexer, sets new input
 283 setInput:function (input, yy) {
 284         this.yy = yy || this.yy || {};
 285         this._input = input;
 286         this._more = this._backtrack = this.done = false;
 287         this.yylineno = this.yyleng = 0;
 288         this.yytext = this.matched = this.match = '';
 289         this.conditionStack = ['INITIAL'];
 290         this.yylloc = {
 291             first_line: 1,
 292             first_column: 0,
 293             last_line: 1,
 294             last_column: 0
 295         };
 296         if (this.options.ranges) {
 297             this.yylloc.range = [0,0];
 298         }
 299         this.offset = 0;
 300         return this;
 301     },
 302
 303 // consumes and returns one char from the input
 304 input:function () {
 305         var ch = this._input[0];
 306         this.yytext += ch;
 307         this.yyleng++;
 308         this.offset++;
 309         this.match += ch;
 310         this.matched += ch;
 311         var lines = ch.match(/(?:\r\n?|\n).*/g);
 312         if (lines) {
 313             this.yylineno++;
 314             this.yylloc.last_line++;
 315         } else {
 316             this.yylloc.last_column++;
 317         }
 318         if (this.options.ranges) {
 319             this.yylloc.range[1]++;
 320         }
 321
 322         this._input = this._input.slice(1);
 323         return ch;
 324     },
 325
 326 // unshifts one char (or a string) into the input
 327 unput:function (ch) {
 328         var len = ch.length;
 329         var lines = ch.split(/(?:\r\n?|\n)/g);
 330
 331         this._input = ch + this._input;
 332         this.yytext = this.yytext.substr(0, this.yytext.length - len);
 333         //this.yyleng -= len;
 334         this.offset -= len;
 335         var oldLines = this.match.split(/(?:\r\n?|\n)/g);
 336         this.match = this.match.substr(0, this.match.length - 1);
 337         this.matched = this.matched.substr(0, this.matched.length - 1);
 338
 339         if (lines.length - 1) {
 340             this.yylineno -= lines.length - 1;
 341         }
 342         var r = this.yylloc.range;
 343
 344         this.yylloc = {
 345             first_line: this.yylloc.first_line,
 346             last_line: this.yylineno + 1,
 347             first_column: this.yylloc.first_column,
 348             last_column: lines ?
 349                 (lines.length === oldLines.length ? this.yylloc.first_column : 0)
 350                  + oldLines[oldLines.length - lines.length].length - lines[0].length :
 351               this.yylloc.first_column - len
 352         };
 353
 354         if (this.options.ranges) {
 355             this.yylloc.range = [r[0], r[0] + this.yyleng - len];
 356         }
 357         this.yyleng = this.yytext.length;
 358         return this;
 359     },
 360
 361 // When called from action, caches matched text and appends it on next action
 362 more:function () {
 363         this._more = true;
 364         return this;
 365     },
 366
 367 // 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.
 368 reject:function () {
 369         if (this.options.backtrack_lexer) {
 370             this._backtrack = true;
 371         } else {
 372             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(), {
 373                 text: "",
 374                 token: null,
 375                 line: this.yylineno
 376             });
 377
 378         }
 379         return this;
 380     },
 381
 382 // retain first n characters of the match
 383 less:function (n) {
 384         this.unput(this.match.slice(n));
 385     },
 386
 387 // displays already matched input, i.e. for error messages
 388 pastInput:function () {
 389         var past = this.matched.substr(0, this.matched.length - this.match.length);
 390         return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
 391     },
 392
 393 // displays upcoming input, i.e. for error messages
 394 upcomingInput:function () {
 395         var next = this.match;
 396         if (next.length < 20) {
 397             next += this._input.substr(0, 20-next.length);
 398         }
 399         return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
 400     },
 401
 402 // displays the character position where the lexing error occurred, i.e. for error messages
 403 showPosition:function () {
 404         var pre = this.pastInput();
 405         var c = new Array(pre.length + 1).join("-");
 406         return pre + this.upcomingInput() + "\n" + c + "^";
 407     },
 408
 409 // test the lexed token: return FALSE when not a match, otherwise return token
 410 test_match:function (match, indexed_rule) {
 411         var token,
 412             lines,
 413             backup;
 414
 415         if (this.options.backtrack_lexer) {
 416             // save context
 417             backup = {
 418                 yylineno: this.yylineno,
 419                 yylloc: {
 420                     first_line: this.yylloc.first_line,
 421                     last_line: this.last_line,
 422                     first_column: this.yylloc.first_column,
 423                     last_column: this.yylloc.last_column
 424                 },
 425                 yytext: this.yytext,
 426                 match: this.match,
 427                 matches: this.matches,
 428                 matched: this.matched,
 429                 yyleng: this.yyleng,
 430                 offset: this.offset,
 431                 _more: this._more,
 432                 _input: this._input,
 433                 yy: this.yy,
 434                 conditionStack: this.conditionStack.slice(0),
 435                 done: this.done
 436             };
 437             if (this.options.ranges) {
 438                 backup.yylloc.range = this.yylloc.range.slice(0);
 439             }
 440         }
 441
 442         lines = match[0].match(/(?:\r\n?|\n).*/g);
 443         if (lines) {
 444             this.yylineno += lines.length;
 445         }
 446         this.yylloc = {
 447             first_line: this.yylloc.last_line,
 448             last_line: this.yylineno + 1,
 449             first_column: this.yylloc.last_column,
 450             last_column: lines ?
 451                          lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
 452                          this.yylloc.last_column + match[0].length
 453         };
 454         this.yytext += match[0];
 455         this.match += match[0];
 456         this.matches = match;
 457         this.yyleng = this.yytext.length;
 458         if (this.options.ranges) {
 459             this.yylloc.range = [this.offset, this.offset += this.yyleng];
 460         }
 461         this._more = false;
 462         this._backtrack = false;
 463         this._input = this._input.slice(match[0].length);
 464         this.matched += match[0];
 465         token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
 466         if (this.done && this._input) {
 467             this.done = false;
 468         }
 469         if (token) {
 470             return token;
 471         } else if (this._backtrack) {
 472             // recover context
 473             for (var k in backup) {
 474                 this[k] = backup[k];
 475             }
 476             return false; // rule action called reject() implying the next rule should be tested instead.
 477         }
 478         return false;
 479     },
 480
 481 // return next match in input
 482 next:function () {
 483         if (this.done) {
 484             return this.EOF;
 485         }
 486         if (!this._input) {
 487             this.done = true;
 488         }
 489
 490         var token,
 491             match,
 492             tempMatch,
 493             index;
 494         if (!this._more) {
 495             this.yytext = '';
 496             this.match = '';
 497         }
 498         var rules = this._currentRules();
 499         for (var i = 0; i < rules.length; i++) {
 500             tempMatch = this._input.match(this.rules[rules[i]]);
 501             if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
 502                 match = tempMatch;
 503                 index = i;
 504                 if (this.options.backtrack_lexer) {
 505                     token = this.test_match(tempMatch, rules[i]);
 506                     if (token !== false) {
 507                         return token;
 508                     } else if (this._backtrack) {
 509                         match = false;
 510                         continue; // rule action called reject() implying a rule MISmatch.
 511                     } else {
 512                         // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
 513                         return false;
 514                     }
 515                 } else if (!this.options.flex) {
 516                     break;
 517                 }
 518             }
 519         }
 520         if (match) {
 521             token = this.test_match(match, rules[index]);
 522             if (token !== false) {
 523                 return token;
 524             }
 525             // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
 526             return false;
 527         }
 528         if (this._input === "") {
 529             return this.EOF;
 530         } else {
 531             return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
 532                 text: "",
 533                 token: null,
 534                 line: this.yylineno
 535             });
 536         }
 537     },
 538
 539 // return next match that has a token
 540 lex:function lex() {
 541         var r = this.next();
 542         if (r) {
 543             return r;
 544         } else {
 545             return this.lex();
 546         }
 547     },
 548
 549 // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
 550 begin:function begin(condition) {
 551         this.conditionStack.push(condition);
 552     },
 553
 554 // pop the previously active lexer condition state off the condition stack
 555 popState:function popState() {
 556         var n = this.conditionStack.length - 1;
 557         if (n > 0) {
 558             return this.conditionStack.pop();
 559         } else {
 560             return this.conditionStack[0];
 561         }
 562     },
 563
 564 // produce the lexer rule set which is active for the currently active lexer condition state
 565 _currentRules:function _currentRules() {
 566         if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
 567             return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
 568         } else {
 569             return this.conditions["INITIAL"].rules;
 570         }
 571     },
 572
 573 // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
 574 topState:function topState(n) {
 575         n = this.conditionStack.length - 1 - Math.abs(n || 0);
 576         if (n >= 0) {
 577             return this.conditionStack[n];
 578         } else {
 579             return "INITIAL";
 580         }
 581     },
 582
 583 // alias for begin(condition)
 584 pushState:function pushState(condition) {
 585         this.begin(condition);
 586     },
 587
 588 // return the number of states currently on the stack
 589 stateStackSize:function stateStackSize() {
 590         return this.conditionStack.length;
 591     },
 592 options: {},
 593 performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
 594 var YYSTATE=YY_START;
 595 switch($avoiding_name_collisions) {
 596 case 0:return 5
 597 break;
 598 case 1:/* skip whitespace */
 599 break;
 600 case 2:return 8
 601 break;
 602 case 3:return 16
 603 break;
 604 case 4:return 17
 605 break;
 606 case 5:return 11
 607 break;
 608 case 6:return 10
 609 break;
 610 case 7:return 9
 611 break;
 612 case 8:return 14
 613 break;
 614 case 9:return 15
 615 break;
 616 case 10:return 12
 617 break;
 618 case 11:return 7
 619 break;
 620 case 12:return 7
 621 break;
 622 case 13:return 7
 623 break;
 624 case 14:return 7
 625 break;
 626 case 15:return 7
 627 break;
 628 case 16:return 7
 629 break;
 630 case 17:return 7
 631 break;
 632 case 18:return 7
 633 break;
 634 case 19:return 7
 635 break;
 636 case 20:return 7
 637 break;
 638 case 21:return 7
 639 break;
 640 case 22:return 7
 641 break;
 642 case 23:return 7
 643 break;
 644 case 24:return 13
 645 break;
 646 case 25:return 13
 647 break;
 648 case 26:return 13
 649 break;
 650 case 27:return 13
 651 break;
 652 case 28:return 13
 653 break;
 654 case 29:return 13
 655 break;
 656 case 30:return 13
 657 break;
 658 case 31:return 13
 659 break;
 660 case 32:return 7
 661 break;
 662 case 33:return 13
 663 break;
 664 case 34:return 7
 665 break;
 666 case 35:return 13
 667 break;
 668 case 36:return 7
 669 break;
 670 case 37:return 13
 671 break;
 672 case 38:return 13
 673 break;
 674 case 39:return 7
 675 break;
 676 case 40:return 13
 677 break;
 678 case 41:return 13
 679 break;
 680 case 42:return 13
 681 break;
 682 case 43:return 13
 683 break;
 684 case 44:return 13
 685 break;
 686 case 45:return 7
 687 break;
 688 case 46:return 13
 689 break;
 690 case 47:return 7
 691 break;
 692 case 48:return 7
 693 break;
 694 case 49:return 7
 695 break;
 696 case 50:return 7
 697 break;
 698 case 51:return 7
 699 break;
 700 case 52:return 7
 701 break;
 702 case 53:return 7
 703 break;
 704 case 54:return 7
 705 break;
 706 case 55:return 7
 707 break;
 708 case 56:return 7
 709 break;
 710 case 57:return 7
 711 break;
 712 case 58:return 7
 713 break;
 714 case 59:return 7
 715 break;
 716 case 60:return 7
 717 break;
 718 case 61:return 7
 719 break;
 720 case 62:return 7
 721 break;
 722 case 63:return 13
 723 break;
 724 case 64:return 7
 725 break;
 726 case 65:return 7
 727 break;
 728 case 66:return 13
 729 break;
 730 case 67:return 7
 731 break;
 732 case 68:return 7
 733 break;
 734 case 69:return 7
 735 break;
 736 case 70:return 7
 737 break;
 738 case 71:return 7
 739 break;
 740 case 72:return 7
 741 break;
 742 case 73:return 13
 743 break;
 744 case 74:return 7
 745 break;
 746 case 75:return 13
 747 break;
 748 case 76:return 7
 749 break;
 750 case 77:return 7
 751 break;
 752 case 78:return 7
 753 break;
 754 case 79:return 7
 755 break;
 756 case 80:return 7
 757 break;
 758 case 81:return 7
 759 break;
 760 case 82:return 7
 761 break;
 762 case 83:return 7
 763 break;
 764 case 84:return 7
 765 break;
 766 case 85:return 7
 767 break;
 768 case 86:return 7
 769 break;
 770 case 87:return 7
 771 break;
 772 case 88:return 7
 773 break;
 774 case 89:return 7
 775 break;
 776 case 90:return 7
 777 break;
 778 case 91:return 7
 779 break;
 780 case 92:return 7
 781 break;
 782 case 93:return 7
 783 break;
 784 case 94:return 7
 785 break;
 786 case 95:return 7
 787 break;
 788 case 96:return 7
 789 break;
 790 case 97:return 7
 791 break;
 792 case 98:return 7
 793 break;
 794 case 99:return 7
 795 break;
 796 case 100:return 7
 797 break;
 798 case 101:return 7
 799 break;
 800 case 102:return 7
 801 break;
 802 case 103:return 7
 803 break;
 804 case 104:return 7
 805 break;
 806 case 105:return 7
 807 break;
 808 case 106:return 7
 809 break;
 810 case 107:return 7
 811 break;
 812 case 108:return 7
 813 break;
 814 case 109:return 7
 815 break;
 816 case 110:return 7
 817 break;
 818 case 111:return 7
 819 break;
 820 case 112:return 7
 821 break;
 822 case 113:return 7
 823 break;
 824 case 114:return 7
 825 break;
 826 case 115:return 7
 827 break;
 828 case 116:return 7
 829 break;
 830 case 117:return 7
 831 break;
 832 case 118:return 7
 833 break;
 834 case 119:return 7
 835 break;
 836 case 120:return 7
 837 break;
 838 case 121:return 7
 839 break;
 840 case 122:return 7
 841 break;
 842 case 123:return 7
 843 break;
 844 case 124:return 7
 845 break;
 846 case 125:return 7
 847 break;
 848 case 126:return 7
 849 break;
 850 case 127:return 7
 851 break;
 852 case 128:return 7
 853 break;
 854 case 129:return 7
 855 break;
 856 case 130:return 7
 857 break;
 858 case 131:return 7
 859 break;
 860 case 132:return 7
 861 break;
 862 case 133:return 7
 863 break;
 864 case 134:return 7
 865 break;
 866 case 135:return 7
 867 break;
 868 case 136:return 7
 869 break;
 870 case 137:return 7
 871 break;
 872 case 138:return 7
 873 break;
 874 case 139:return 7
 875 break;
 876 case 140:return 7
 877 break;
 878 case 141:return 7
 879 break;
 880 case 142:return 7
 881 break;
 882 case 143:return 7
 883 break;
 884 case 144:return 7
 885 break;
 886 case 145:return 7
 887 break;
 888 case 146:return 7
 889 break;
 890 case 147:return 7
 891 break;
 892 case 148:return 7
 893 break;
 894 case 149:return 7
 895 break;
 896 case 150:return 7
 897 break;
 898 case 151:return 7
 899 break;
 900 case 152:return 7
 901 break;
 902 case 153:return 7
 903 break;
 904 case 154:return 7
 905 break;
 906 case 155:return 7
 907 break;
 908 case 156:return 7
 909 break;
 910 case 157:return 7
 911 break;
 912 case 158:return 7
 913 break;
 914 case 159:return 7
 915 break;
 916 case 160:return 7
 917 break;
 918 case 161:return 7
 919 break;
 920 case 162:return 7
 921 break;
 922 case 163:return 7
 923 break;
 924 case 164:return 7
 925 break;
 926 case 165:return 7
 927 break;
 928 case 166:return 7
 929 break;
 930 case 167:return 7
 931 break;
 932 case 168:return 7
 933 break;
 934 case 169:return 7
 935 break;
 936 case 170:return 7
 937 break;
 938 case 171:return 7
 939 break;
 940 case 172:return 7
 941 break;
 942 case 173:return 7
 943 break;
 944 case 174:return 7
 945 break;
 946 case 175:return 7
 947 break;
 948 case 176:return 7
 949 break;
 950 case 177:return 7
 951 break;
 952 case 178:return 7
 953 break;
 954 case 179:return 7
 955 break;
 956 case 180:return 7
 957 break;
 958 case 181:return 7
 959 break;
 960 case 182:return 7
 961 break;
 962 case 183:return 7
 963 break;
 964 case 184:return 7
 965 break;
 966 case 185:return 7
 967 break;
 968 case 186:return 7
 969 break;
 970 case 187:return 7
 971 break;
 972 case 188:return 7
 973 break;
 974 case 189:return 7
 975 break;
 976 case 190:return 7
 977 break;
 978 case 191:return 7
 979 break;
 980 case 192:return 7
 981 break;
 982 case 193:return 7
 983 break;
 984 case 194:return 7
 985 break;
 986 case 195:return 7
 987 break;
 988 case 196:return 7
 989 break;
 990 case 197:return 7
 991 break;
 992 case 198:return 7
 993 break;
 994 case 199:return 7
 995 break;
 996 case 200:return 7
 997 break;
 998 case 201:return 7
 999 break;
1000 case 202:return 7
1001 break;
1002 case 203:return 7
1003 break;
1004 case 204:return 7
1005 break;
1006 case 205:return 7
1007 break;
1008 case 206:return 7
1009 break;
1010 case 207:return 7
1011 break;
1012 case 208:return 7
1013 break;
1014 case 209:return 7
1015 break;
1016 case 210:return 7
1017 break;
1018 case 211:return 7
1019 break;
1020 case 212:return 7
1021 break;
1022 case 213:return 7
1023 break;
1024 case 214:return 7
1025 break;
1026 case 215:return 7
1027 break;
1028 case 216:return 7
1029 break;
1030 case 217:return 7
1031 break;
1032 case 218:return 7
1033 break;
1034 case 219:return 7
1035 break;
1036 case 220:return 7
1037 break;
1038 case 221:return 7
1039 break;
1040 case 222:return 7
1041 break;
1042 case 223:return 7
1043 break;
1044 case 224:return 7
1045 break;
1046 case 225:return 7
1047 break;
1048 case 226:return 7
1049 break;
1050 case 227:return 7
1051 break;
1052 case 228:return 7
1053 break;
1054 case 229:return 7
1055 break;
1056 case 230:return 7
1057 break;
1058 case 231:return 7
1059 break;
1060 case 232:return 7
1061 break;
1062 case 233:return 7
1063 break;
1064 case 234:return 7
1065 break;
1066 case 235:return 7
1067 break;
1068 case 236:return 7
1069 break;
1070 case 237:return 7
1071 break;
1072 case 238:return 7
1073 break;
1074 case 239:return 7
1075 break;
1076 case 240:return 7
1077 break;
1078 case 241:return 7
1079 break;
1080 case 242:return 7
1081 break;
1082 case 243:return 7
1083 break;
1084 case 244:return 7
1085 break;
1086 case 245:return 7
1087 break;
1088 case 246:return 7
1089 break;
1090 case 247:return 7
1091 break;
1092 case 248:return 7
1093 break;
1094 case 249:return 7
1095 break;
1096 case 250:return 7
1097 break;
1098 case 251:return 7
1099 break;
1100 case 252:return 7
1101 break;
1102 case 253:return 7
1103 break;
1104 case 254:return 7
1105 break;
1106 case 255:return 7
1107 break;
1108 case 256:return 7
1109 break;
1110 case 257:return 7
1111 break;
1112 case 258:return 7
1113 break;
1114 case 259:return 7
1115 break;
1116 case 260:return 7
1117 break;
1118 case 261:return 7
1119 break;
1120 case 262:return 7
1121 break;
1122 case 263:return 7
1123 break;
1124 case 264:return 7
1125 break;
1126 case 265:return 7
1127 break;
1128 case 266:return 7
1129 break;
1130 case 267:return 7
1131 break;
1132 case 268:return 7
1133 break;
1134 case 269:return 7
1135 break;
1136 case 270:return 7
1137 break;
1138 case 271:return 7
1139 break;
1140 case 272:return 7
1141 break;
1142 case 273:return 7
1143 break;
1144 case 274:return 7
1145 break;
1146 case 275:return 7
1147 break;
1148 case 276:return 7
1149 break;
1150 case 277:return 7
1151 break;
1152 case 278:return 7
1153 break;
1154 case 279:return 7
1155 break;
1156 case 280:return 7
1157 break;
1158 case 281:return 7
1159 break;
1160 case 282:return 7
1161 break;
1162 case 283:return 7
1163 break;
1164 case 284:return 7
1165 break;
1166 case 285:return 7
1167 break;
1168 case 286:return 7
1169 break;
1170 case 287:return 7
1171 break;
1172 case 288:return 7
1173 break;
1174 case 289:return 7
1175 break;
1176 case 290:return 7
1177 break;
1178 case 291:return 7
1179 break;
1180 case 292:return 7
1181 break;
1182 case 293:return 7
1183 break;
1184 case 294:return 7
1185 break;
1186 case 295:return 7
1187 break;
1188 case 296:return 7
1189 break;
1190 case 297:return 7
1191 break;
1192 case 298:return 7
1193 break;
1194 case 299:return 7
1195 break;
1196 case 300:return 7
1197 break;
1198 case 301:return 7
1199 break;
1200 case 302:return 7
1201 break;
1202 case 303:return 7
1203 break;
1204 case 304:return 7
1205 break;
1206 case 305:return 7
1207 break;
1208 case 306:return 7
1209 break;
1210 case 307:return 7
1211 break;
1212 case 308:return 7
1213 break;
1214 case 309:return 7
1215 break;
1216 case 310:return 7
1217 break;
1218 case 311:return 7
1219 break;
1220 case 312:return 7
1221 break;
1222 case 313:return 7
1223 break;
1224 case 314:return 7
1225 break;
1226 case 315:return 7
1227 break;
1228 case 316:return 7
1229 break;
1230 case 317:return 7
1231 break;
1232 case 318:return 7
1233 break;
1234 case 319:return 7
1235 break;
1236 case 320:return 7
1237 break;
1238 case 321:return 7
1239 break;
1240 case 322:return 7
1241 break;
1242 case 323:return 7
1243 break;
1244 case 324:return 7
1245 break;
1246 case 325:return 7
1247 break;
1248 case 326:return 7
1249 break;
1250 case 327:return 7
1251 break;
1252 case 328:return 7
1253 break;
1254 case 329:return 7
1255 break;
1256 case 330:return 7
1257 break;
1258 case 331:return 7
1259 break;
1260 case 332:return 7
1261 break;
1262 case 333:return 7
1263 break;
1264 case 334:return 7
1265 break;
1266 case 335:return 7
1267 break;
1268 case 336:return 7
1269 break;
1270 case 337:return 7
1271 break;
1272 case 338:return 7
1273 break;
1274 case 339:return 7
1275 break;
1276 case 340:return 7
1277 break;
1278 case 341:return 7
1279 break;
1280 case 342:return 7
1281 break;
1282 case 343:return 7
1283 break;
1284 case 344:return 7
1285 break;
1286 case 345:return 7
1287 break;
1288 case 346:return 7
1289 break;
1290 case 347:return 7
1291 break;
1292 case 348:return 7
1293 break;
1294 case 349:return 7
1295 break;
1296 case 350:return 7
1297 break;
1298 case 351:return 7
1299 break;
1300 case 352:return 7
1301 break;
1302 case 353:return 7
1303 break;
1304 case 354:return 7
1305 break;
1306 case 355:return 7
1307 break;
1308 case 356:return 7
1309 break;
1310 case 357:return 7
1311 break;
1312 case 358:return 7
1313 break;
1314 case 359:return 7
1315 break;
1316 case 360:return 7
1317 break;
1318 case 361:return 7
1319 break;
1320 case 362:return 7
1321 break;
1322 case 363:return 7
1323 break;
1324 case 364:return 7
1325 break;
1326 }
1327 },
1328 rules: [/^(?:$)/,/^(?:\s+)/,/^(?:\+)/,/^(?:\()/,/^(?:\))/,/^(?::)/,/^(?:DocumentRef-([0-9A-Za-z-+.]+))/,/^(?:LicenseRef-([0-9A-Za-z-+.]+))/,/^(?:AND)/,/^(?:OR)/,/^(?:WITH)/,/^(?:BSD-3-Clause-No-Nuclear-License-2014)/,/^(?:BSD-3-Clause-No-Nuclear-Warranty)/,/^(?:GPL-2\.0-with-classpath-exception)/,/^(?:GPL-3\.0-with-autoconf-exception)/,/^(?:GPL-2\.0-with-autoconf-exception)/,/^(?:BSD-3-Clause-No-Nuclear-License)/,/^(?:MPL-2\.0-no-copyleft-exception)/,/^(?:GPL-2\.0-with-bison-exception)/,/^(?:GPL-2\.0-with-font-exception)/,/^(?:GPL-2\.0-with-GCC-exception)/,/^(?:CNRI-Python-GPL-Compatible)/,/^(?:GPL-3\.0-with-GCC-exception)/,/^(?:BSD-3-Clause-Attribution)/,/^(?:Classpath-exception-2\.0)/,/^(?:WxWindows-exception-3\.1)/,/^(?:freertos-exception-2\.0)/,/^(?:Autoconf-exception-3\.0)/,/^(?:i2p-gpl-java-exception)/,/^(?:gnu-javamail-exception)/,/^(?:Nokia-Qt-exception-1\.1)/,/^(?:Autoconf-exception-2\.0)/,/^(?:BSD-2-Clause-FreeBSD)/,/^(?:u-boot-exception-2\.0)/,/^(?:zlib-acknowledgement)/,/^(?:Bison-exception-2\.2)/,/^(?:BSD-2-Clause-NetBSD)/,/^(?:CLISP-exception-2\.0)/,/^(?:eCos-exception-2\.0)/,/^(?:BSD-3-Clause-Clear)/,/^(?:Font-exception-2\.0)/,/^(?:FLTK-exception-2\.0)/,/^(?:GCC-exception-2\.0)/,/^(?:Qwt-exception-1\.0)/,/^(?:Libtool-exception)/,/^(?:BSD-3-Clause-LBNL)/,/^(?:GCC-exception-3\.1)/,/^(?:Artistic-1\.0-Perl)/,/^(?:Artistic-1\.0-cl8)/,/^(?:CC-BY-NC-SA-2\.5)/,/^(?:MIT-advertising)/,/^(?:BSD-Source-Code)/,/^(?:CC-BY-NC-SA-4\.0)/,/^(?:LiLiQ-Rplus-1\.1)/,/^(?:CC-BY-NC-SA-3\.0)/,/^(?:BSD-4-Clause-UC)/,/^(?:CC-BY-NC-SA-2\.0)/,/^(?:CC-BY-NC-SA-1\.0)/,/^(?:CC-BY-NC-ND-4\.0)/,/^(?:CC-BY-NC-ND-3\.0)/,/^(?:CC-BY-NC-ND-2\.5)/,/^(?:CC-BY-NC-ND-2\.0)/,/^(?:CC-BY-NC-ND-1\.0)/,/^(?:LZMA-exception)/,/^(?:BitTorrent-1\.1)/,/^(?:CrystalStacker)/,/^(?:FLTK-exception)/,/^(?:SugarCRM-1\.1\.3)/,/^(?:BSD-Protection)/,/^(?:BitTorrent-1\.0)/,/^(?:HaskellReport)/,/^(?:Interbase-1\.0)/,/^(?:StandardML-NJ)/,/^(?:mif-exception)/,/^(?:Frameworx-1\.0)/,/^(?:389-exception)/,/^(?:CC-BY-NC-2\.0)/,/^(?:CC-BY-NC-2\.5)/,/^(?:CC-BY-NC-3\.0)/,/^(?:CC-BY-NC-4\.0)/,/^(?:W3C-19980720)/,/^(?:CC-BY-SA-1\.0)/,/^(?:CC-BY-SA-2\.0)/,/^(?:CC-BY-SA-2\.5)/,/^(?:CC-BY-ND-2\.0)/,/^(?:CC-BY-SA-4\.0)/,/^(?:CC-BY-SA-3\.0)/,/^(?:Artistic-1\.0)/,/^(?:Artistic-2\.0)/,/^(?:CC-BY-ND-2\.5)/,/^(?:CC-BY-ND-3\.0)/,/^(?:CC-BY-ND-4\.0)/,/^(?:CC-BY-ND-1\.0)/,/^(?:BSD-4-Clause)/,/^(?:BSD-3-Clause)/,/^(?:BSD-2-Clause)/,/^(?:CC-BY-NC-1\.0)/,/^(?:bzip2-1\.0\.6)/,/^(?:Unicode-TOU)/,/^(?:CNRI-Jython)/,/^(?:ImageMagick)/,/^(?:Adobe-Glyph)/,/^(?:CUA-OPL-1\.0)/,/^(?:OLDAP-2\.2\.2)/,/^(?:LiLiQ-R-1\.1)/,/^(?:bzip2-1\.0\.5)/,/^(?:LiLiQ-P-1\.1)/,/^(?:OLDAP-2\.0\.1)/,/^(?:OLDAP-2\.2\.1)/,/^(?:CNRI-Python)/,/^(?:XFree86-1\.1)/,/^(?:OSET-PL-2\.1)/,/^(?:Apache-2\.0)/,/^(?:Watcom-1\.0)/,/^(?:PostgreSQL)/,/^(?:Python-2\.0)/,/^(?:RHeCos-1\.1)/,/^(?:EUDatagrid)/,/^(?:Spencer-99)/,/^(?:Intel-ACPI)/,/^(?:CECILL-1\.0)/,/^(?:CECILL-1\.1)/,/^(?:JasPer-2\.0)/,/^(?:CECILL-2\.0)/,/^(?:CECILL-2\.1)/,/^(?:gSOAP-1\.3b)/,/^(?:Spencer-94)/,/^(?:Apache-1\.1)/,/^(?:Spencer-86)/,/^(?:Apache-1\.0)/,/^(?:ClArtistic)/,/^(?:TORQUE-1\.1)/,/^(?:CATOSL-1\.1)/,/^(?:Adobe-2006)/,/^(?:Zimbra-1\.4)/,/^(?:Zimbra-1\.3)/,/^(?:Condor-1\.1)/,/^(?:CC-BY-3\.0)/,/^(?:CC-BY-2\.5)/,/^(?:OLDAP-2\.4)/,/^(?:SGI-B-1\.1)/,/^(?:SISSL-1\.2)/,/^(?:SGI-B-1\.0)/,/^(?:OLDAP-2\.3)/,/^(?:CC-BY-4\.0)/,/^(?:Crossword)/,/^(?:SimPL-2\.0)/,/^(?:OLDAP-2\.2)/,/^(?:OLDAP-2\.1)/,/^(?:ErlPL-1\.1)/,/^(?:LPPL-1\.3a)/,/^(?:LPPL-1\.3c)/,/^(?:OLDAP-2\.0)/,/^(?:Leptonica)/,/^(?:CPOL-1\.02)/,/^(?:OLDAP-1\.4)/,/^(?:OLDAP-1\.3)/,/^(?:CC-BY-2\.0)/,/^(?:Unlicense)/,/^(?:OLDAP-2\.8)/,/^(?:OLDAP-1\.2)/,/^(?:MakeIndex)/,/^(?:OLDAP-2\.7)/,/^(?:OLDAP-1\.1)/,/^(?:Sleepycat)/,/^(?:D-FSL-1\.0)/,/^(?:CC-BY-1\.0)/,/^(?:OLDAP-2\.6)/,/^(?:WXwindows)/,/^(?:NPOSL-3\.0)/,/^(?:FreeImage)/,/^(?:SGI-B-2\.0)/,/^(?:OLDAP-2\.5)/,/^(?:Beerware)/,/^(?:Newsletr)/,/^(?:NBPL-1\.0)/,/^(?:NASA-1\.3)/,/^(?:NLOD-1\.0)/,/^(?:AGPL-1\.0)/,/^(?:OCLC-2\.0)/,/^(?:ODbL-1\.0)/,/^(?:PDDL-1\.0)/,/^(?:Motosoto)/,/^(?:Afmparse)/,/^(?:ANTLR-PD)/,/^(?:LPL-1\.02)/,/^(?:Abstyles)/,/^(?:eCos-2\.0)/,/^(?:APSL-1\.0)/,/^(?:LPPL-1\.2)/,/^(?:LPPL-1\.1)/,/^(?:LPPL-1\.0)/,/^(?:APSL-1\.1)/,/^(?:APSL-2\.0)/,/^(?:Info-ZIP)/,/^(?:Zend-2\.0)/,/^(?:IBM-pibs)/,/^(?:LGPL-2\.0)/,/^(?:LGPL-3\.0)/,/^(?:LGPL-2\.1)/,/^(?:GFDL-1\.3)/,/^(?:PHP-3\.01)/,/^(?:GFDL-1\.2)/,/^(?:GFDL-1\.1)/,/^(?:AGPL-3\.0)/,/^(?:Giftware)/,/^(?:EUPL-1\.1)/,/^(?:RPSL-1\.0)/,/^(?:EUPL-1\.0)/,/^(?:MIT-enna)/,/^(?:CECILL-B)/,/^(?:diffmark)/,/^(?:CECILL-C)/,/^(?:CDDL-1\.0)/,/^(?:Sendmail)/,/^(?:CDDL-1\.1)/,/^(?:CPAL-1\.0)/,/^(?:APSL-1\.2)/,/^(?:NPL-1\.1)/,/^(?:AFL-1\.2)/,/^(?:Caldera)/,/^(?:AFL-2\.0)/,/^(?:FSFULLR)/,/^(?:AFL-2\.1)/,/^(?:VSL-1\.0)/,/^(?:VOSTROM)/,/^(?:UPL-1\.0)/,/^(?:Dotseqn)/,/^(?:CPL-1\.0)/,/^(?:dvipdfm)/,/^(?:EPL-1\.0)/,/^(?:OCCT-PL)/,/^(?:ECL-1\.0)/,/^(?:Latex2e)/,/^(?:ECL-2\.0)/,/^(?:GPL-1\.0)/,/^(?:GPL-2\.0)/,/^(?:GPL-3\.0)/,/^(?:AFL-3\.0)/,/^(?:LAL-1\.2)/,/^(?:LAL-1\.3)/,/^(?:EFL-1\.0)/,/^(?:EFL-2\.0)/,/^(?:gnuplot)/,/^(?:Aladdin)/,/^(?:LPL-1\.0)/,/^(?:libtiff)/,/^(?:Entessa)/,/^(?:AMDPLPA)/,/^(?:IPL-1\.0)/,/^(?:OPL-1\.0)/,/^(?:OSL-1\.0)/,/^(?:OSL-1\.1)/,/^(?:OSL-2\.0)/,/^(?:OSL-2\.1)/,/^(?:OSL-3\.0)/,/^(?:OpenSSL)/,/^(?:ZPL-2\.1)/,/^(?:PHP-3\.0)/,/^(?:ZPL-2\.0)/,/^(?:ZPL-1\.1)/,/^(?:CC0-1\.0)/,/^(?:SPL-1\.0)/,/^(?:psutils)/,/^(?:MPL-1\.0)/,/^(?:QPL-1\.0)/,/^(?:MPL-1\.1)/,/^(?:MPL-2\.0)/,/^(?:APL-1\.0)/,/^(?:RPL-1\.1)/,/^(?:RPL-1\.5)/,/^(?:MIT-CMU)/,/^(?:Multics)/,/^(?:Eurosym)/,/^(?:BSL-1\.0)/,/^(?:MIT-feh)/,/^(?:Saxpath)/,/^(?:Borceux)/,/^(?:OFL-1\.1)/,/^(?:OFL-1\.0)/,/^(?:AFL-1\.1)/,/^(?:YPL-1\.1)/,/^(?:YPL-1\.0)/,/^(?:NPL-1\.0)/,/^(?:iMatix)/,/^(?:mpich2)/,/^(?:APAFML)/,/^(?:Bahyph)/,/^(?:RSA-MD)/,/^(?:psfrag)/,/^(?:Plexus)/,/^(?:eGenix)/,/^(?:Glulxe)/,/^(?:SAX-PD)/,/^(?:Imlib2)/,/^(?:Wsuipa)/,/^(?:LGPLLR)/,/^(?:Libpng)/,/^(?:xinetd)/,/^(?:MITNFA)/,/^(?:NetCDF)/,/^(?:Naumen)/,/^(?:SMPPL)/,/^(?:Nunit)/,/^(?:FSFUL)/,/^(?:GL2PS)/,/^(?:SMLNJ)/,/^(?:Rdisc)/,/^(?:Noweb)/,/^(?:Nokia)/,/^(?:SISSL)/,/^(?:Qhull)/,/^(?:Intel)/,/^(?:Glide)/,/^(?:Xerox)/,/^(?:AMPAS)/,/^(?:WTFPL)/,/^(?:MS-PL)/,/^(?:XSkat)/,/^(?:MS-RL)/,/^(?:MirOS)/,/^(?:RSCPL)/,/^(?:TMate)/,/^(?:OGTSL)/,/^(?:FSFAP)/,/^(?:NCSA)/,/^(?:Zlib)/,/^(?:SCEA)/,/^(?:SNIA)/,/^(?:NGPL)/,/^(?:NOSL)/,/^(?:ADSL)/,/^(?:MTLL)/,/^(?:NLPL)/,/^(?:Ruby)/,/^(?:JSON)/,/^(?:Barr)/,/^(?:0BSD)/,/^(?:Xnet)/,/^(?:Cube)/,/^(?:curl)/,/^(?:DSDP)/,/^(?:Fair)/,/^(?:HPND)/,/^(?:TOSL)/,/^(?:IJG)/,/^(?:SWL)/,/^(?:Vim)/,/^(?:FTL)/,/^(?:ICU)/,/^(?:OML)/,/^(?:NRL)/,/^(?:DOC)/,/^(?:TCL)/,/^(?:W3C)/,/^(?:NTP)/,/^(?:IPA)/,/^(?:ISC)/,/^(?:X11)/,/^(?:AAL)/,/^(?:AML)/,/^(?:xpp)/,/^(?:Zed)/,/^(?:MIT)/,/^(?:Mup)/],
1329 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,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364],"inclusive":true}}
1330 });
1331 return lexer;
1332 })();
1333 parser.lexer = lexer;
1334 function Parser () {
1335   this.yy = {};
1336 }
1337 Parser.prototype = parser;parser.Parser = Parser;
1338 return new Parser;
1339 })();
1340
1341
1342 if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
1343 exports.parser = spdxparse;
1344 exports.Parser = spdxparse.Parser;
1345 exports.parse = function () { return spdxparse.parse.apply(spdxparse, arguments); };
1346 exports.main = function commonjsMain(args) {
1347     if (!args[1]) {
1348         console.log('Usage: '+args[0]+' FILE');
1349         process.exit(1);
1350     }
1351     var source = require('fs').readFileSync(require('path').normalize(args[1]), "utf8");
1352     return exports.parser.parse(source);
1353 };
1354 if (typeof module !== 'undefined' && require.main === module) {
1355   exports.main(process.argv.slice(1));
1356 }
1357 }