parser.js

/* parser generated by jison 0.4.15-113 */
/*
 * Returns a Parser object of the following structure:
 *
 *  Parser: {
 *    yy: {}
 *  }
 *
 *  Parser.prototype: {
 *    yy: {},
 *    trace: function(errorMessage, errorHash),
 *    JisonParserError: function(msg, hash),
 *    symbols_: {associative list: name ==> number},
 *    terminals_: {associative list: number ==> name},
 *    productions_: [...],
 *    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$, ...),
 *                (where `...` denotes the (optional) additional arguments the user passed to `parser.parse(str, ...)`)
 *    table: [...],
 *    defaultActions: {...},
 *    parseError: function(str, hash),
 *    parse: function(input),
 *
 *    lexer: {
 *        EOF: 1,
 *        ERROR: 2,
 *        JisonLexerError: function(msg, hash),
 *        parseError: function(str, hash),
 *        setInput: function(input),
 *        input: function(),
 *        unput: function(str),
 *        more: function(),
 *        reject: 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),
 *        stateStackSize: function(),
 *
 *        options: { ... },
 *
 *        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)
 *    token_id:    (the produced terminal token numeric ID, if any)
 *    line:        (yylineno)
 *    loc:         (yylloc)
 *  }
 *
 * parser (grammar) errors will also provide these additional members:
 *
 *  {
 *    expected:    (array describing the set of expected tokens; may be empty when we cannot easily produce such a set)
 *    recoverable: (boolean: TRUE when the parser MAY have an error recovery rule available for this particular error)
 *    state_stack: (array: the current parser LALR/LR internal state stack; this can be used, for instance, for advanced error analysis and reporting)
 *  }
 *
 * while `this` will reference the current parser instance.
 *
 *  When `parseError` is invoked by the lexer, `this` will still reference the related *parser* instance, while these additional `hash` fields will also be provided:
 *
 *  {
 *    lexer:       (reference to the current lexer instance which reported the error)
 *  }
 *
 * ---
 *
 * You can specify parser options by setting / modifying the `.yy` object of your Parser instance.
 * These options are available:
 *
 * ### options which are global for all parser instances
 *
 *  Parser.pre_parse: function(yy)
 *                              optional: you can specify a pre_parse() function in the chunk following the grammar, 
 *                              i.e. after the last `%%`.
 *  Parser.post_parse: function(yy, retval) { return retval; }
 *                              optional: you can specify a post_parse() function in the chunk following the grammar, 
 *                              i.e. after the last `%%`. When it does not return any value, the parser will return 
 *                              the original `retval`.
 *
 * ### options which can be set up per parser instance
 *  
 *  yy: {
 *      pre_parse:  function(yy)
 *                              optional: is invoked before the parse cycle starts (and before the first invocation 
 *                              of `lex()`) but immediately after the invocation of parser.pre_parse()).
 *      post_parse: function(yy, retval) { return retval; }
 *                              optional: is invoked when the parse terminates due to success ('accept') or failure 
 *                              (even when exceptions are thrown).  `retval` contains the return value to be produced
 *                              by `Parser.parse()`; this function can override the return value by returning another. 
 *                              When it does not return any value, the parser will return the original `retval`. 
 *                              This function is invoked immediately before `Parser.post_parse()`.
 *      parseError: function(str, hash)
 *                              optional: overrides the default `parseError` function.
 *  }
 *
 *  parser.lexer.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.
 *      pre_lex:  function()
 *                              optional: is invoked before the lexer is invoked to produce another token.
 *                              `this` refers to the Lexer object.
 *      post_lex: function(token) { return token; }
 *                              optional: is invoked when the lexer has produced a token `token`;
 *                              this function can override the returned token value by returning another.
 *                              When it does not return any (truthy) value, the lexer will return the original `token`.
 *                              `this` refers to the Lexer object.
 *  }
 */
var bnf = (function () {
// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript
// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript
function JisonParserError(msg, hash) {
    this.message = msg;
    this.hash = hash;
    var stacktrace = (new Error(msg)).stack;
    if (stacktrace) {
      this.stack = stacktrace;
    }
}
JisonParserError.prototype = Object.create(Error.prototype);
JisonParserError.prototype.constructor = JisonParserError;
JisonParserError.prototype.name = 'JisonParserError';

function __expand__(k, v, o) {
  o = o || {};
  for (var l = k.length; l--; ) {
    o[k[l]] = v;
  }
  return o;
}

var $V0=[129,135,138,140,142,147,148,153,159,161,164,165,166],
    $V1=[135,151],
    $V2=[129,135,138,140,142,147,148,151,153,159,161,164,165,166,171],
    $V3=[129,135,138,140,142,147,148,151,152,153,159,161,164,165,166],
    $V4=[59,123,124,129,135,138,140,142,147,148,151,152,153,159,161,164,165,166,189],
    $V5=[59,124,129,132,135,138,140,142,147,148,151,153,159,161,164,165,166,193],
    $V6=[132,193],
    $V7=[129,132],
    $V8=[129,135,138,140,142,147,148,151,152,153,159,161,164,165,166,171],
    $V9=[40,59,123,124,135,151,152,187,189],
    $Va=[59,123,124,135,189],
    $Vb=[40,41,59,123,124,135,151,152,187,189],
    $Vc=[40,41,59,123,124,135,151,152,186,187,189],
    $Vd=[40,41,42,43,59,63,123,124,135,151,152,186,187,189],
    $Ve=[40,41,124,151,152],
    $Vf=[123,125],
    $Vg=[41,124];

var parser = {
trace: function trace() { },
JisonParserError: JisonParserError,
yy: {},
symbols_: {
  "$accept": 0,
  "$end": 1,
  "%%": 129,
  "(": 40,
  ")": 41,
  "*": 42,
  "+": 43,
  ":": 58,
  ";": 59,
  "=": 61,
  "?": 63,
  "ACTION": 135,
  "ACTION_BODY": 191,
  "ALIAS": 186,
  "ARROW_ACTION": 189,
  "CODE": 196,
  "EOF": 132,
  "ID": 151,
  "IMPORT": 148,
  "INCLUDE": 193,
  "INTEGER": 172,
  "LEFT": 164,
  "LEX_BLOCK": 140,
  "NAME": 157,
  "NONASSOC": 166,
  "OPTIONS": 153,
  "OPTIONS_END": 155,
  "OPTION_VALUE": 158,
  "PARSER_TYPE": 161,
  "PARSE_PARAM": 159,
  "PATH": 194,
  "PREC": 187,
  "RIGHT": 165,
  "START": 138,
  "STRING": 152,
  "TOKEN": 142,
  "TOKEN_TYPE": 171,
  "UNKNOWN_DECL": 147,
  "action": 181,
  "action_body": 188,
  "action_comments_body": 190,
  "associativity": 163,
  "declaration": 137,
  "declaration_list": 128,
  "error": 2,
  "expression": 184,
  "expression_suffix": 182,
  "extra_parser_module_code": 133,
  "full_token_definition": 167,
  "full_token_definitions": 143,
  "grammar": 130,
  "handle": 179,
  "handle_action": 178,
  "handle_list": 177,
  "handle_sublist": 183,
  "id": 139,
  "id_list": 173,
  "import_name": 149,
  "import_path": 150,
  "include_macro_code": 136,
  "module_code_chunk": 195,
  "operator": 141,
  "option": 156,
  "option_list": 154,
  "optional_action_header_block": 134,
  "optional_end_block": 131,
  "optional_module_code_chunk": 192,
  "optional_token_description": 170,
  "optional_token_type": 168,
  "optional_token_value": 169,
  "options": 146,
  "parse_param": 144,
  "parser_type": 145,
  "prec": 180,
  "production": 176,
  "production_list": 175,
  "spec": 127,
  "suffix": 185,
  "symbol": 162,
  "token_id": 174,
  "token_list": 160,
  "{": 123,
  "|": 124,
  "}": 125
},
terminals_: {
  1: "$end",
  2: "error",
  40: "(",
  41: ")",
  42: "*",
  43: "+",
  58: ":",
  59: ";",
  61: "=",
  63: "?",
  123: "{",
  124: "|",
  125: "}",
  129: "%%",
  132: "EOF",
  135: "ACTION",
  138: "START",
  140: "LEX_BLOCK",
  142: "TOKEN",
  147: "UNKNOWN_DECL",
  148: "IMPORT",
  151: "ID",
  152: "STRING",
  153: "OPTIONS",
  155: "OPTIONS_END",
  157: "NAME",
  158: "OPTION_VALUE",
  159: "PARSE_PARAM",
  161: "PARSER_TYPE",
  164: "LEFT",
  165: "RIGHT",
  166: "NONASSOC",
  171: "TOKEN_TYPE",
  172: "INTEGER",
  186: "ALIAS",
  187: "PREC",
  189: "ARROW_ACTION",
  191: "ACTION_BODY",
  193: "INCLUDE",
  194: "PATH",
  196: "CODE"
},
nonterminals_: {
  "$accept": {
    0: "spec $end"
  },
  "spec": {
    1: "declaration_list %% grammar optional_end_block EOF"
  },
  "optional_end_block": {
    2: "<epsilon>",
    3: "%% extra_parser_module_code"
  },
  "optional_action_header_block": {
    4: "<epsilon>",
    5: "optional_action_header_block ACTION",
    6: "optional_action_header_block include_macro_code"
  },
  "declaration_list": {
    7: "declaration_list declaration",
    8: "<epsilon>"
  },
  "declaration": {
    9: "START id",
    10: "LEX_BLOCK",
    11: "operator",
    12: "TOKEN full_token_definitions",
    13: "ACTION",
    14: "include_macro_code",
    15: "parse_param",
    16: "parser_type",
    17: "options",
    18: "UNKNOWN_DECL",
    19: "IMPORT import_name import_path"
  },
  "import_name": {
    20: "ID",
    21: "STRING"
  },
  "import_path": {
    22: "ID",
    23: "STRING"
  },
  "options": {
    24: "OPTIONS option_list OPTIONS_END"
  },
  "option_list": {
    25: "option_list option",
    26: "option"
  },
  "option": {
    27: "NAME",
    28: "NAME = OPTION_VALUE",
    29: "NAME = NAME"
  },
  "parse_param": {
    30: "PARSE_PARAM token_list"
  },
  "parser_type": {
    31: "PARSER_TYPE symbol"
  },
  "operator": {
    32: "associativity token_list"
  },
  "associativity": {
    33: "LEFT",
    34: "RIGHT",
    35: "NONASSOC"
  },
  "token_list": {
    36: "token_list symbol",
    37: "symbol"
  },
  "full_token_definitions": {
    38: "full_token_definitions full_token_definition",
    39: "full_token_definition"
  },
  "full_token_definition": {
    40: "optional_token_type id optional_token_value optional_token_description"
  },
  "optional_token_type": {
    41: "<epsilon>",
    42: "TOKEN_TYPE"
  },
  "optional_token_value": {
    43: "<epsilon>",
    44: "INTEGER"
  },
  "optional_token_description": {
    45: "<epsilon>",
    46: "STRING"
  },
  "id_list": {
    47: "id_list id",
    48: "id"
  },
  "token_id": {
    49: "TOKEN_TYPE id",
    50: "id"
  },
  "grammar": {
    51: "optional_action_header_block production_list"
  },
  "production_list": {
    52: "production_list production",
    53: "production"
  },
  "production": {
    54: "id : handle_list ;"
  },
  "handle_list": {
    55: "handle_list | handle_action",
    56: "handle_action"
  },
  "handle_action": {
    57: "handle prec action"
  },
  "handle": {
    58: "handle expression_suffix",
    59: "<epsilon>"
  },
  "handle_sublist": {
    60: "handle_sublist | handle",
    61: "handle"
  },
  "expression_suffix": {
    62: "expression suffix ALIAS",
    63: "expression suffix"
  },
  "expression": {
    64: "ID",
    65: "STRING",
    66: "( handle_sublist )"
  },
  "suffix": {
    67: "<epsilon>",
    68: "*",
    69: "?",
    70: "+"
  },
  "prec": {
    71: "PREC symbol",
    72: "<epsilon>"
  },
  "symbol": {
    73: "id",
    74: "STRING"
  },
  "id": {
    75: "ID"
  },
  "action": {
    76: "{ action_body }",
    77: "ACTION",
    78: "include_macro_code",
    79: "ARROW_ACTION",
    80: "<epsilon>"
  },
  "action_body": {
    81: "<epsilon>",
    82: "action_comments_body",
    83: "action_body { action_body } action_comments_body",
    84: "action_body { action_body }"
  },
  "action_comments_body": {
    85: "ACTION_BODY",
    86: "action_comments_body ACTION_BODY"
  },
  "extra_parser_module_code": {
    87: "optional_module_code_chunk",
    88: "optional_module_code_chunk include_macro_code extra_parser_module_code"
  },
  "include_macro_code": {
    89: "INCLUDE PATH",
    90: "INCLUDE error"
  },
  "module_code_chunk": {
    91: "CODE",
    92: "module_code_chunk CODE"
  },
  "optional_module_code_chunk": {
    93: "module_code_chunk",
    94: "<epsilon>"
  }
},
productions_: [
  0,
  [
    127,
    5
  ],
  [
    131,
    0
  ],
  [
    131,
    2
  ],
  [
    134,
    0
  ],
  [
    134,
    2
  ],
  [
    134,
    2
  ],
  [
    128,
    2
  ],
  [
    128,
    0
  ],
  [
    137,
    2
  ],
  [
    137,
    1
  ],
  [
    137,
    1
  ],
  [
    137,
    2
  ],
  [
    137,
    1
  ],
  [
    137,
    1
  ],
  [
    137,
    1
  ],
  [
    137,
    1
  ],
  [
    137,
    1
  ],
  [
    137,
    1
  ],
  [
    137,
    3
  ],
  [
    149,
    1
  ],
  [
    149,
    1
  ],
  [
    150,
    1
  ],
  [
    150,
    1
  ],
  [
    146,
    3
  ],
  [
    154,
    2
  ],
  [
    154,
    1
  ],
  [
    156,
    1
  ],
  [
    156,
    3
  ],
  [
    156,
    3
  ],
  [
    144,
    2
  ],
  [
    145,
    2
  ],
  [
    141,
    2
  ],
  [
    163,
    1
  ],
  [
    163,
    1
  ],
  [
    163,
    1
  ],
  [
    160,
    2
  ],
  [
    160,
    1
  ],
  [
    143,
    2
  ],
  [
    143,
    1
  ],
  [
    167,
    4
  ],
  [
    168,
    0
  ],
  [
    168,
    1
  ],
  [
    169,
    0
  ],
  [
    169,
    1
  ],
  [
    170,
    0
  ],
  [
    170,
    1
  ],
  [
    173,
    2
  ],
  [
    173,
    1
  ],
  [
    174,
    2
  ],
  [
    174,
    1
  ],
  [
    130,
    2
  ],
  [
    175,
    2
  ],
  [
    175,
    1
  ],
  [
    176,
    4
  ],
  [
    177,
    3
  ],
  [
    177,
    1
  ],
  [
    178,
    3
  ],
  [
    179,
    2
  ],
  [
    179,
    0
  ],
  [
    183,
    3
  ],
  [
    183,
    1
  ],
  [
    182,
    3
  ],
  [
    182,
    2
  ],
  [
    184,
    1
  ],
  [
    184,
    1
  ],
  [
    184,
    3
  ],
  [
    185,
    0
  ],
  [
    185,
    1
  ],
  [
    185,
    1
  ],
  [
    185,
    1
  ],
  [
    180,
    2
  ],
  [
    180,
    0
  ],
  [
    162,
    1
  ],
  [
    162,
    1
  ],
  [
    139,
    1
  ],
  [
    181,
    3
  ],
  [
    181,
    1
  ],
  [
    181,
    1
  ],
  [
    181,
    1
  ],
  [
    181,
    0
  ],
  [
    188,
    0
  ],
  [
    188,
    1
  ],
  [
    188,
    5
  ],
  [
    188,
    4
  ],
  [
    190,
    1
  ],
  [
    190,
    2
  ],
  [
    133,
    1
  ],
  [
    133,
    3
  ],
  [
    136,
    2
  ],
  [
    136,
    2
  ],
  [
    195,
    1
  ],
  [
    195,
    2
  ],
  [
    192,
    1
  ],
  [
    192,
    0
  ]
],
performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */, yystack, options) {
/* this == yyval */

var $0 = $$.length - 1;
switch (yystate) {
case 1 : 
/*! Production::     spec : declaration_list '%%' grammar optional_end_block EOF */
 
            this.$ = $$[$0-4];
            if ($$[$0-1] && $$[$0-1].trim() !== '') {
                yy.addDeclaration(this.$, { include: $$[$0-1] });
            }
            return extend(this.$, $$[$0-2]);
         
break;
case 3 : 
/*! Production::     optional_end_block : '%%' extra_parser_module_code */
 case 30 : 
/*! Production::     parse_param : PARSE_PARAM token_list */
 case 31 : 
/*! Production::     parser_type : PARSER_TYPE symbol */
 case 49 : 
/*! Production::     token_id : TOKEN_TYPE id */
 case 50 : 
/*! Production::     token_id : id */
 case 64 : 
/*! Production::     expression : ID */
 case 73 : 
/*! Production::     symbol : id */
 case 74 : 
/*! Production::     symbol : STRING */
 case 75 : 
/*! Production::     id : ID */
 case 77 : 
/*! Production::     action : ACTION */
 case 78 : 
/*! Production::     action : include_macro_code */
 case 82 : 
/*! Production::     action_body : action_comments_body */
 case 85 : 
/*! Production::     action_comments_body : ACTION_BODY */
 case 87 : 
/*! Production::     extra_parser_module_code : optional_module_code_chunk */
 case 91 : 
/*! Production::     module_code_chunk : CODE */
 case 93 : 
/*! Production::     optional_module_code_chunk : module_code_chunk */
  this.$ = $$[$0];  
break;
case 4 : 
/*! Production::     optional_action_header_block :  */
 case 8 : 
/*! Production::     declaration_list :  */
  this.$ = {};  
break;
case 5 : 
/*! Production::     optional_action_header_block : optional_action_header_block ACTION */
 case 6 : 
/*! Production::     optional_action_header_block : optional_action_header_block include_macro_code */
 
            this.$ = $$[$0-1];
            yy.addDeclaration(this.$, { actionInclude: $$[$0] });
         
break;
case 7 : 
/*! Production::     declaration_list : declaration_list declaration */
  this.$ = $$[$0-1]; yy.addDeclaration(this.$, $$[$0]);  
break;
case 9 : 
/*! Production::     declaration : START id */
  this.$ = {start: $$[$0]};  
break;
case 10 : 
/*! Production::     declaration : LEX_BLOCK */
  this.$ = {lex: $$[$0]};  
break;
case 11 : 
/*! Production::     declaration : operator */
  this.$ = {operator: $$[$0]};  
break;
case 12 : 
/*! Production::     declaration : TOKEN full_token_definitions */
  this.$ = {token_list: $$[$0]};  
break;
case 13 : 
/*! Production::     declaration : ACTION */
 case 14 : 
/*! Production::     declaration : include_macro_code */
  this.$ = {include: $$[$0]};  
break;
case 15 : 
/*! Production::     declaration : parse_param */
  this.$ = {parseParam: $$[$0]};  
break;
case 16 : 
/*! Production::     declaration : parser_type */
  this.$ = {parserType: $$[$0]};  
break;
case 17 : 
/*! Production::     declaration : options */
  this.$ = {options: $$[$0]};  
break;
case 18 : 
/*! Production::     declaration : UNKNOWN_DECL */
  this.$ = {unknownDecl: $$[$0]};  
break;
case 19 : 
/*! Production::     declaration : IMPORT import_name import_path */
  this.$ = {imports: {name: $$[$0-1], path: $$[$0]}};  
break;
case 24 : 
/*! Production::     options : OPTIONS option_list OPTIONS_END */
 case 76 : 
/*! Production::     action : '{' action_body '}' */
  this.$ = $$[$0-1];  
break;
case 25 : 
/*! Production::     option_list : option_list option */
 case 36 : 
/*! Production::     token_list : token_list symbol */
 case 38 : 
/*! Production::     full_token_definitions : full_token_definitions full_token_definition */
 case 47 : 
/*! Production::     id_list : id_list id */
  this.$ = $$[$0-1]; this.$.push($$[$0]);  
break;
case 26 : 
/*! Production::     option_list : option */
 case 37 : 
/*! Production::     token_list : symbol */
 case 39 : 
/*! Production::     full_token_definitions : full_token_definition */
 case 48 : 
/*! Production::     id_list : id */
 case 56 : 
/*! Production::     handle_list : handle_action */
  this.$ = [$$[$0]];  
break;
case 27 : 
/*! Production::     option : NAME[option] */
  this.$ = [$$[$0], true];  
break;
case 28 : 
/*! Production::     option : NAME[option] '=' OPTION_VALUE[value] */
 case 29 : 
/*! Production::     option : NAME[option] '=' NAME[value] */
  this.$ = [$$[$0-2], $$[$0]];  
break;
case 32 : 
/*! Production::     operator : associativity token_list */
  this.$ = [$$[$0-1]]; this.$.push.apply(this.$, $$[$0]);  
break;
case 33 : 
/*! Production::     associativity : LEFT */
  this.$ = 'left';  
break;
case 34 : 
/*! Production::     associativity : RIGHT */
  this.$ = 'right';  
break;
case 35 : 
/*! Production::     associativity : NONASSOC */
  this.$ = 'nonassoc';  
break;
case 40 : 
/*! Production::     full_token_definition : optional_token_type id optional_token_value optional_token_description */
 
            this.$ = {id: $$[$0-2]};
            if ($$[$0-3]) {
                this.$.type = $$[$0-3];
            }
            if ($$[$0-1]) {
                this.$.value = $$[$0-1];
            }
            if ($$[$0]) {
                this.$.description = $$[$0];
            }
         
break;
case 41 : 
/*! Production::     optional_token_type :  */
 case 43 : 
/*! Production::     optional_token_value :  */
 case 45 : 
/*! Production::     optional_token_description :  */
  this.$ = false;  
break;
case 51 : 
/*! Production::     grammar : optional_action_header_block production_list */
 
            this.$ = $$[$0-1];
            this.$.grammar = $$[$0];
         
break;
case 52 : 
/*! Production::     production_list : production_list production */
 
            this.$ = $$[$0-1];
            if ($$[$0][0] in this.$) {
                this.$[$$[$0][0]] = this.$[$$[$0][0]].concat($$[$0][1]);
            } else {
                this.$[$$[$0][0]] = $$[$0][1];
            }
         
break;
case 53 : 
/*! Production::     production_list : production */
  this.$ = {}; this.$[$$[$0][0]] = $$[$0][1];  
break;
case 54 : 
/*! Production::     production : id ':' handle_list ';' */
 this.$ = [$$[$0-3], $$[$0-1]]; 
break;
case 55 : 
/*! Production::     handle_list : handle_list '|' handle_action */
 
            this.$ = $$[$0-2];
            this.$.push($$[$0]);
         
break;
case 57 : 
/*! Production::     handle_action : handle prec action */
 
            this.$ = [($$[$0-2].length ? $$[$0-2].join(' ') : '')];
            if ($$[$0]) {
                this.$.push($$[$0]);
            }
            if ($$[$0-1]) {
                this.$.push($$[$0-1]);
            }
            if (this.$.length === 1) {
                this.$ = this.$[0];
            }
         
break;
case 58 : 
/*! Production::     handle : handle expression_suffix */
 
            this.$ = $$[$0-1];
            this.$.push($$[$0]);
         
break;
case 59 : 
/*! Production::     handle :  */
 
            this.$ = [];
         
break;
case 60 : 
/*! Production::     handle_sublist : handle_sublist '|' handle */
 
            this.$ = $$[$0-2];
            this.$.push($$[$0].join(' '));
         
break;
case 61 : 
/*! Production::     handle_sublist : handle */
 
            this.$ = [$$[$0].join(' ')];
         
break;
case 62 : 
/*! Production::     expression_suffix : expression suffix ALIAS */
 
            this.$ = $$[$0-2] + $$[$0-1] + "[" + $$[$0] + "]";
         
break;
case 63 : 
/*! Production::     expression_suffix : expression suffix */
 case 86 : 
/*! Production::     action_comments_body : action_comments_body ACTION_BODY */
 case 92 : 
/*! Production::     module_code_chunk : module_code_chunk CODE */
 
            this.$ = $$[$0-1] + $$[$0];
         
break;
case 65 : 
/*! Production::     expression : STRING */
 
            // Re-encode the string *anyway* as it will
            // be made part of the rule rhs a.k.a. production (type: *string*) again and we want
            // to be able to handle all tokens, including *significant space*
            // encoded as literal tokens in a grammar such as this: `rule: A ' ' B`.
            if ($$[$0].indexOf("'") >= 0) {
                this.$ = '"' + $$[$0] + '"';
            } else {
                this.$ = "'" + $$[$0] + "'";
            }
         
break;
case 66 : 
/*! Production::     expression : '(' handle_sublist ')' */
 
            this.$ = '(' + $$[$0-1].join(' | ') + ')';
         
break;
case 67 : 
/*! Production::     suffix :  */
 case 80 : 
/*! Production::     action :  */
 case 81 : 
/*! Production::     action_body :  */
 case 94 : 
/*! Production::     optional_module_code_chunk :  */
  this.$ = '';  
break;
case 71 : 
/*! Production::     prec : PREC symbol */
 
            this.$ = { prec: $$[$0] };
         
break;
case 72 : 
/*! Production::     prec :  */
 
            this.$ = null;
         
break;
case 79 : 
/*! Production::     action : ARROW_ACTION */
  this.$ = '$$ =' + $$[$0] + ';';  
break;
case 83 : 
/*! Production::     action_body : action_body '{' action_body '}' action_comments_body */
  this.$ = $$[$0-4] + $$[$0-3] + $$[$0-2] + $$[$0-1] + $$[$0];  
break;
case 84 : 
/*! Production::     action_body : action_body '{' action_body '}' */
  this.$ = $$[$0-3] + $$[$0-2] + $$[$0-1] + $$[$0];  
break;
case 88 : 
/*! Production::     extra_parser_module_code : optional_module_code_chunk include_macro_code extra_parser_module_code */
  this.$ = $$[$0-2] + $$[$0-1] + $$[$0];  
break;
case 89 : 
/*! Production::     include_macro_code : INCLUDE PATH */
 
console.log('options: ', options);
            var fileContent = fs.readFileSync($$[$0], { encoding: 'utf-8' });
            // And no, we don't support nested '%include':
            this.$ = '\n// Included by Jison: ' + $$[$0] + ':\n\n' + fileContent + '\n\n// End Of Include by Jison: ' + $$[$0] + '\n\n';
         
break;
case 90 : 
/*! Production::     include_macro_code : INCLUDE error */
 
            console.error("%include MUST be followed by a valid file path");
         
break;
}
},
table: [
  __expand__($V0, [
      2,
      8
    ], {127:1,128:2,193:[
      2,
      8
    ]
  }),
  {
    1: [
      3
    ]
  },
  {
    129: [
      1,
      3
    ],
    135: [
      1,
      9
    ],
    136: 10,
    137: 4,
    138: [
      1,
      5
    ],
    140: [
      1,
      6
    ],
    141: 7,
    142: [
      1,
      8
    ],
    144: 11,
    145: 12,
    146: 13,
    147: [
      1,
      14
    ],
    148: [
      1,
      15
    ],
    153: [
      1,
      20
    ],
    159: [
      1,
      18
    ],
    161: [
      1,
      19
    ],
    163: 16,
    164: [
      1,
      21
    ],
    165: [
      1,
      22
    ],
    166: [
      1,
      23
    ],
    193: [
      1,
      17
    ]
  },
  __expand__($V1, [
      2,
      4
    ], {130:24,134:25,193:[
      2,
      4
    ]
  }),
  __expand__($V0, [
      2,
      7
    ], {193:[
      2,
      7
    ]
  }),
  {
    139: 26,
    151: [
      1,
      27
    ]
  },
  __expand__($V0, [
      2,
      10
    ], {193:[
      2,
      10
    ]
  }),
  __expand__($V0, [
      2,
      11
    ], {193:[
      2,
      11
    ]
  }),
  {
    143: 28,
    151: [
      2,
      41
    ],
    167: 29,
    168: 30,
    171: [
      1,
      31
    ]
  },
  __expand__($V0, [
      2,
      13
    ], {193:[
      2,
      13
    ]
  }),
  __expand__($V0, [
      2,
      14
    ], {193:[
      2,
      14
    ]
  }),
  __expand__($V0, [
      2,
      15
    ], {193:[
      2,
      15
    ]
  }),
  __expand__($V0, [
      2,
      16
    ], {193:[
      2,
      16
    ]
  }),
  __expand__($V0, [
      2,
      17
    ], {193:[
      2,
      17
    ]
  }),
  __expand__($V0, [
      2,
      18
    ], {193:[
      2,
      18
    ]
  }),
  {
    149: 32,
    151: [
      1,
      33
    ],
    152: [
      1,
      34
    ]
  },
  {
    139: 37,
    151: [
      1,
      27
    ],
    152: [
      1,
      38
    ],
    160: 35,
    162: 36
  },
  {
    2: [
      1,
      40
    ],
    194: [
      1,
      39
    ]
  },
  {
    139: 37,
    151: [
      1,
      27
    ],
    152: [
      1,
      38
    ],
    160: 41,
    162: 36
  },
  {
    139: 37,
    151: [
      1,
      27
    ],
    152: [
      1,
      38
    ],
    162: 42
  },
  {
    154: 43,
    156: 44,
    157: [
      1,
      45
    ]
  },
  {
    151: [
      2,
      33
    ],
    152: [
      2,
      33
    ]
  },
  {
    151: [
      2,
      34
    ],
    152: [
      2,
      34
    ]
  },
  {
    151: [
      2,
      35
    ],
    152: [
      2,
      35
    ]
  },
  {
    129: [
      1,
      47
    ],
    131: 46,
    132: [
      2,
      2
    ]
  },
  {
    135: [
      1,
      49
    ],
    136: 50,
    139: 52,
    151: [
      1,
      27
    ],
    175: 48,
    176: 51,
    193: [
      1,
      17
    ]
  },
  __expand__($V0, [
      2,
      9
    ], {193:[
      2,
      9
    ]
  }),
  __expand__([58,59,123,124,129,135,138,140,142,147,148,151,152,153,159,161,164,165,166,171,172,189], [
      2,
      75
    ], {193:[
      2,
      75
    ]
  }),
  __expand__($V0, [
      2,
      12
    ], {168:30,167:53,151:[
      2,
      41
    ],171:[
      1,
      31
    ],193:[
      2,
      12
    ]
  }),
  __expand__($V2, [
      2,
      39
    ], {193:[
      2,
      39
    ]
  }),
  {
    139: 54,
    151: [
      1,
      27
    ]
  },
  {
    151: [
      2,
      42
    ]
  },
  {
    150: 55,
    151: [
      1,
      56
    ],
    152: [
      1,
      57
    ]
  },
  {
    151: [
      2,
      20
    ],
    152: [
      2,
      20
    ]
  },
  {
    151: [
      2,
      21
    ],
    152: [
      2,
      21
    ]
  },
  __expand__($V0, [
      2,
      32
    ], {139:37,162:58,151:[
      1,
      27
    ],152:[
      1,
      38
    ],193:[
      2,
      32
    ]
  }),
  __expand__($V3, [
      2,
      37
    ], {193:[
      2,
      37
    ]
  }),
  __expand__($V4, [
      2,
      73
    ], {193:[
      2,
      73
    ]
  }),
  __expand__($V4, [
      2,
      74
    ], {193:[
      2,
      74
    ]
  }),
  __expand__($V5, [
      2,
      89
    ], {196:[
      2,
      89
    ]
  }),
  __expand__($V5, [
      2,
      90
    ], {196:[
      2,
      90
    ]
  }),
  __expand__($V0, [
      2,
      30
    ], {139:37,162:58,151:[
      1,
      27
    ],152:[
      1,
      38
    ],193:[
      2,
      30
    ]
  }),
  __expand__($V0, [
      2,
      31
    ], {193:[
      2,
      31
    ]
  }),
  {
    155: [
      1,
      59
    ],
    156: 60,
    157: [
      1,
      45
    ]
  },
  {
    155: [
      2,
      26
    ],
    157: [
      2,
      26
    ]
  },
  {
    61: [
      1,
      61
    ],
    155: [
      2,
      27
    ],
    157: [
      2,
      27
    ]
  },
  {
    132: [
      1,
      62
    ]
  },
  __expand__($V6, [
      2,
      94
    ], {133:63,192:64,195:65,196:[
      1,
      66
    ]
  }),
  __expand__($V7, [
      2,
      51
    ], {139:52,151:[
      1,
      27
    ],176:67
  }),
  __expand__($V1, [
      2,
      5
    ], {193:[
      2,
      5
    ]
  }),
  __expand__($V1, [
      2,
      6
    ], {193:[
      2,
      6
    ]
  }),
  __expand__($V7, [
      2,
      53
    ], {151:[
      2,
      53
    ]
  }),
  {
    58: [
      1,
      68
    ]
  },
  __expand__($V2, [
      2,
      38
    ], {193:[
      2,
      38
    ]
  }),
  __expand__($V8, [
      2,
      43
    ], {169:69,172:[
      1,
      70
    ],193:[
      2,
      43
    ]
  }),
  __expand__($V0, [
      2,
      19
    ], {193:[
      2,
      19
    ]
  }),
  __expand__($V0, [
      2,
      22
    ], {193:[
      2,
      22
    ]
  }),
  __expand__($V0, [
      2,
      23
    ], {193:[
      2,
      23
    ]
  }),
  __expand__($V3, [
      2,
      36
    ], {193:[
      2,
      36
    ]
  }),
  __expand__($V0, [
      2,
      24
    ], {193:[
      2,
      24
    ]
  }),
  {
    155: [
      2,
      25
    ],
    157: [
      2,
      25
    ]
  },
  {
    157: [
      1,
      72
    ],
    158: [
      1,
      71
    ]
  },
  {
    1: [
      2,
      1
    ]
  },
  {
    132: [
      2,
      3
    ]
  },
  {
    132: [
      2,
      87
    ],
    136: 73,
    193: [
      1,
      17
    ]
  },
  __expand__($V6, [
      2,
      93
    ], {196:[
      1,
      74
    ]
  }),
  __expand__($V6, [
      2,
      91
    ], {196:[
      2,
      91
    ]
  }),
  __expand__($V7, [
      2,
      52
    ], {151:[
      2,
      52
    ]
  }),
  __expand__($V9, [
      2,
      59
    ], {177:75,178:76,179:77,193:[
      2,
      59
    ]
  }),
  __expand__($V2, [
      2,
      45
    ], {170:78,152:[
      1,
      79
    ],193:[
      2,
      45
    ]
  }),
  __expand__($V8, [
      2,
      44
    ], {193:[
      2,
      44
    ]
  }),
  {
    155: [
      2,
      28
    ],
    157: [
      2,
      28
    ]
  },
  {
    155: [
      2,
      29
    ],
    157: [
      2,
      29
    ]
  },
  __expand__($V6, [
      2,
      94
    ], {192:64,195:65,133:80,196:[
      1,
      66
    ]
  }),
  __expand__($V6, [
      2,
      92
    ], {196:[
      2,
      92
    ]
  }),
  {
    59: [
      1,
      81
    ],
    124: [
      1,
      82
    ]
  },
  {
    59: [
      2,
      56
    ],
    124: [
      2,
      56
    ]
  },
  __expand__($Va, [
      2,
      72
    ], {180:83,182:84,184:86,40:[
      1,
      89
    ],151:[
      1,
      87
    ],152:[
      1,
      88
    ],187:[
      1,
      85
    ],193:[
      2,
      72
    ]
  }),
  __expand__($V2, [
      2,
      40
    ], {193:[
      2,
      40
    ]
  }),
  __expand__($V2, [
      2,
      46
    ], {193:[
      2,
      46
    ]
  }),
  {
    132: [
      2,
      88
    ]
  },
  __expand__($V7, [
      2,
      54
    ], {151:[
      2,
      54
    ]
  }),
  __expand__($V9, [
      2,
      59
    ], {179:77,178:90,193:[
      2,
      59
    ]
  }),
  __expand__([59,124], [
      2,
      80
    ], {181:91,136:94,123:[
      1,
      92
    ],135:[
      1,
      93
    ],189:[
      1,
      95
    ],193:[
      1,
      17
    ]
  }),
  __expand__($Vb, [
      2,
      58
    ], {193:[
      2,
      58
    ]
  }),
  {
    139: 37,
    151: [
      1,
      27
    ],
    152: [
      1,
      38
    ],
    162: 96
  },
  __expand__($Vc, [
      2,
      67
    ], {185:97,42:[
      1,
      98
    ],43:[
      1,
      100
    ],63:[
      1,
      99
    ],193:[
      2,
      67
    ]
  }),
  __expand__($Vd, [
      2,
      64
    ], {193:[
      2,
      64
    ]
  }),
  __expand__($Vd, [
      2,
      65
    ], {193:[
      2,
      65
    ]
  }),
  __expand__($Ve, [
      2,
      59
    ], {179:102,183:101
  }),
  {
    59: [
      2,
      55
    ],
    124: [
      2,
      55
    ]
  },
  {
    59: [
      2,
      57
    ],
    124: [
      2,
      57
    ]
  },
  __expand__($Vf, [
      2,
      81
    ], {188:103,190:104,191:[
      1,
      105
    ]
  }),
  {
    59: [
      2,
      77
    ],
    124: [
      2,
      77
    ]
  },
  {
    59: [
      2,
      78
    ],
    124: [
      2,
      78
    ]
  },
  {
    59: [
      2,
      79
    ],
    124: [
      2,
      79
    ]
  },
  __expand__($Va, [
      2,
      71
    ], {193:[
      2,
      71
    ]
  }),
  __expand__($Vb, [
      2,
      63
    ], {186:[
      1,
      106
    ],193:[
      2,
      63
    ]
  }),
  __expand__($Vc, [
      2,
      68
    ], {193:[
      2,
      68
    ]
  }),
  __expand__($Vc, [
      2,
      69
    ], {193:[
      2,
      69
    ]
  }),
  __expand__($Vc, [
      2,
      70
    ], {193:[
      2,
      70
    ]
  }),
  {
    41: [
      1,
      107
    ],
    124: [
      1,
      108
    ]
  },
  __expand__($Vg, [
      2,
      61
    ], {182:84,40:[
      1,
      89
    ],151:[
      1,
      87
    ],152:[
      1,
      88
    ],184:86
  }),
  {
    123: [
      1,
      110
    ],
    125: [
      1,
      109
    ]
  },
  __expand__($Vf, [
      2,
      82
    ], {191:[
      1,
      111
    ]
  }),
  __expand__($Vf, [
      2,
      85
    ], {191:[
      2,
      85
    ]
  }),
  __expand__($Vb, [
      2,
      62
    ], {193:[
      2,
      62
    ]
  }),
  __expand__($Vd, [
      2,
      66
    ], {193:[
      2,
      66
    ]
  }),
  __expand__($Ve, [
      2,
      59
    ], {179:112
  }),
  {
    59: [
      2,
      76
    ],
    124: [
      2,
      76
    ]
  },
  __expand__($Vf, [
      2,
      81
    ], {190:104,188:113,191:[
      1,
      105
    ]
  }),
  __expand__($Vf, [
      2,
      86
    ], {191:[
      2,
      86
    ]
  }),
  __expand__($Vg, [
      2,
      60
    ], {182:84,40:[
      1,
      89
    ],151:[
      1,
      87
    ],152:[
      1,
      88
    ],184:86
  }),
  {
    123: [
      1,
      110
    ],
    125: [
      1,
      114
    ]
  },
  __expand__($Vf, [
      2,
      84
    ], {190:115,191:[
      1,
      105
    ]
  }),
  __expand__($Vf, [
      2,
      83
    ], {191:[
      1,
      111
    ]
  })
],
defaultActions: {
  31: [
    2,
    42
  ],
  62: [
    2,
    1
  ],
  63: [
    2,
    3
  ],
  80: [
    2,
    88
  ]
},
parseError: function parseError(str, hash) {
    if (hash.recoverable) {
        this.trace(str);
    } else {
        throw new this.JisonParserError(str, hash);
    }
},
parse: function parse(input) {
    var self = this,
        stack = [0],

        vstack = [null],    // semantic value stack
        lstack = [],        // location stack
        table = this.table,
        yytext = '',
        yylineno = 0,
        yyleng = 0,
        recovering = 0,     // (only used when the grammar contains error recovery rules)
        TERROR = 2,
        EOF = 1;

    var args = lstack.slice.call(arguments, 1);

    //this.reductionCount = this.shiftCount = 0;

    var lexer;
    if (this.__lexer__) {
        lexer = this.__lexer__;
    } else {
        lexer = this.__lexer__ = Object.create(this.lexer);
    }

    var sharedState = {
      yy: {}
    };
    // copy state
    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;

    // Does the shared state override the default `parseError` that already comes with this instance?
    if (typeof sharedState.yy.parseError === 'function') {
        this.parseError = sharedState.yy.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 = lexer.lex() || EOF;
        // if token isn't its numeric value, convert
        if (typeof token !== 'number') {
            token = self.symbols_[token] || token;
        }
        return token;
    }

    var symbol;
    var preErrorSymbol = null;
    var state, action, a, r;
    var yyval = {};
    var p, len, this_production, lstack_begin, lstack_end, newState;
    var expected = [];
    var retval = false;

    if (this.pre_parse) {
        this.pre_parse.call(this, sharedState.yy);
    }
    if (sharedState.yy.pre_parse) {
        sharedState.yy.pre_parse.call(this, sharedState.yy);
    }

    // Return the rule stack depth where the nearest error rule can be found.
    // Return FALSE when no error recovery rule was found.
    function locateNearestErrorRecoveryRule(state) {
        var stack_probe = stack.length - 1;
        var depth = 0;

        // try to recover from error
        for (;;) {
            // check for error recovery rule in this state
            if ((TERROR.toString()) in table[state]) {
                return depth;
            }
            if (state === 0 || stack_probe < 2) {
                return false; // No suitable error recovery rule available.
            }
            stack_probe -= 2; // popStack(1): [symbol, action]
            state = stack[stack_probe];
            ++depth;
        }
    }


    function collect_expected_token_set(state) {
        var tokenset = [];
        for (var p in table[state]) {
            if (p > TERROR) {
                if (self.terminal_descriptions_ && self.terminal_descriptions_[p]) {
                    tokenset.push(self.terminal_descriptions_[p]);
                }
                else if (self.terminals_[p]) {
                    tokenset.push("'" + self.terminals_[p] + "'");
                }
            }
        }
        return tokenset;
    }

    try {
        for (;;) {
            // retrieve state number from top of stack
            state = stack[stack.length - 1];

            // use default actions if available
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol === 'undefined') {
                    symbol = lex();
                }
                // read action for current state and first input
                action = table[state] && table[state][symbol];
            }

            // handle parse error
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var error_rule_depth;
                var errStr = '';

                if (!recovering) {
                    // first see if there's any chance at hitting an error recovery rule:
                    error_rule_depth = locateNearestErrorRecoveryRule(state);

                    // Report error
                    expected = collect_expected_token_set(state);
                    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) + "'"));
                    }
                    a = this.parseError(errStr, p = {
                        text: lexer.match,
                        token: this.terminals_[symbol] || symbol,
                        token_id: symbol,
                        line: lexer.yylineno,
                        loc: yyloc,
                        expected: expected,
                        recoverable: (error_rule_depth !== false),
                        state_stack: stack
                    });
                    if (!p.recoverable) {
                        retval = a;
                        break;
                    }
                } else if (preErrorSymbol !== EOF) {
                    error_rule_depth = locateNearestErrorRecoveryRule(state);
                }

                // just recovered from another error
                if (recovering === 3) {
                    if (symbol === EOF || preErrorSymbol === EOF) {
                        retval = this.parseError(errStr || 'Parsing halted while starting to recover from another error.', {
                            text: lexer.match,
                            token: this.terminals_[symbol] || symbol,
                            token_id: symbol,
                            line: lexer.yylineno,
                            loc: yyloc,
                            expected: expected,
                            recoverable: false,
                            state_stack: stack
                        });
                        break;
                    }

                    // discard current lookahead and grab another
                    yyleng = lexer.yyleng;
                    yytext = lexer.yytext;
                    yylineno = lexer.yylineno;
                    yyloc = lexer.yylloc;
                    symbol = lex();
                }

                // try to recover from error
                if (error_rule_depth === false) {
                    retval = this.parseError(errStr || 'Parsing halted. No suitable error recovery rule available.', {
                        text: lexer.match,
                        token: this.terminals_[symbol] || symbol,
                        token_id: symbol,
                        line: lexer.yylineno,
                        loc: yyloc,
                        expected: expected,
                        recoverable: false,
                        state_stack: stack
                    });
                    break;
                }
                popStack(error_rule_depth);

                preErrorSymbol = (symbol === TERROR ? null : symbol); // save the lookahead token
                symbol = TERROR;         // insert generic error symbol as new lookahead
                state = stack[stack.length - 1];
                action = table[state] && table[state][TERROR];
                recovering = 3; // allow 3 real symbols to be shifted before reporting a new error
            }


            // this shouldn't happen, unless resolve defaults are off
            if (action[0] instanceof Array && action.length > 1) {
                retval = this.parseError('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    token_id: symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected,
                    recoverable: false,
                    state_stack: stack
                });
                break;
            }

            switch (action[0]) {
            case 1: // shift
                //this.shiftCount++;

                stack.push(symbol);
                vstack.push(lexer.yytext);
                lstack.push(lexer.yylloc);
                stack.push(action[1]); // push state
                symbol = null;
                if (!preErrorSymbol) { // normal execution / no error
                    yyleng = lexer.yyleng;
                    yytext = lexer.yytext;
                    yylineno = lexer.yylineno;
                    yyloc = lexer.yylloc;
                    if (recovering > 0) {
                        recovering--;
                    }
                } else {
                    // error just occurred, resume old lookahead f/ before error
                    symbol = preErrorSymbol;
                    preErrorSymbol = null;
                }
                continue;

            case 2:
                // reduce
                //this.reductionCount++;

                this_production = this.productions_[action[1]];
                len = this_production[1];
                lstack_end = lstack.length;
                lstack_begin = lstack_end - (len || 1);
                lstack_end--;

                // perform semantic action
                yyval.$ = vstack[vstack.length - len]; // default to $$ = $1
                // default location, uses first token for firsts, last for lasts
                yyval._$ = {
                    first_line: lstack[lstack_begin].first_line,
                    last_line: lstack[lstack_end].last_line,
                    first_column: lstack[lstack_begin].first_column,
                    last_column: lstack[lstack_end].last_column
                };
                if (ranges) {
                  yyval._$.range = [lstack[lstack_begin].range[0], lstack[lstack_end].range[1]];
                }
                r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack, stack].concat(args));

                if (typeof r !== 'undefined') {
                    retval = r;
                    break;
                }

                // pop off stack
                if (len) {
                    popStack(len);
                }

                stack.push(this_production[0]);    // push nonterminal (reduce)
                vstack.push(yyval.$);
                lstack.push(yyval._$);
                // goto new state = table[STATE][NONTERMINAL]
                newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                stack.push(newState);
                continue;

            case 3:
                // accept
                retval = true;
                break;
            }

            // break out of loop: we accept or fail with error
            break;
        }
    } finally {
        var rv;

        if (sharedState.yy.post_parse) {
            rv = sharedState.yy.post_parse.call(this, sharedState.yy, retval);
            if (typeof rv !== 'undefined') retval = rv;
        }
        if (this.post_parse) {
            rv = this.post_parse.call(this, sharedState.yy, retval);
            if (typeof rv !== 'undefined') retval = rv;
        }
    }

    return retval;
}
};

var fs = require('fs');
var transform = require('./ebnf-transform').transform;
var ebnf = false;


// transform ebnf to bnf if necessary
function extend(json, grammar) {
    json.bnf = ebnf ? transform(grammar.grammar) : grammar.grammar;
    if (grammar.actionInclude) {
        json.actionInclude = grammar.actionInclude;
    }
    return json;
}


/* generated by jison-lex 0.3.4-112 */
var lexer = (function () {
// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript
// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript
function JisonLexerError(msg, hash) {
    this.message = msg;
    this.hash = hash;
    var stacktrace = (new Error(msg)).stack;
    if (stacktrace) {
      this.stack = stacktrace;
    }
}
JisonLexerError.prototype = Object.create(Error.prototype);
JisonLexerError.prototype.constructor = JisonLexerError;
JisonLexerError.prototype.name = 'JisonLexerError';

var lexer = {

EOF:1,

ERROR:2,

parseError:function parseError(str, hash) {
        if (this.yy.parser && typeof this.yy.parser.parseError === 'function') {
            return this.yy.parser.parseError(str, hash) || this.ERROR;
        } else {
            throw new this.JisonLexerError(str);
        }
    },

// resets the lexer, sets new input
setInput:function (input, yy) {
        this.yy = yy || this.yy || {};
        this._input = input;
        this._more = this._backtrack = this._signaled_error_token = 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 () {
        if (!this._input) {
            this.done = true;
            return null;
        }
        var ch = this._input[0];
        this.yytext += ch;
        this.yyleng++;
        this.offset++;
        this.match += ch;
        this.matched += ch;
        // Count the linenumber up when we hit the LF (or a stand-alone CR).
        // On CRLF, the linenumber is incremented when you fetch the CR or the CRLF combo
        // and we advance immediately past the LF as well, returning both together as if
        // it was all a single 'character' only.
        var slice_len = 1;
        var lines = false;
        if (ch === '\n') {
            lines = true;
        } else if (ch === '\r') {
            lines = true;
            var ch2 = this._input[1];
            if (ch2 === '\n') {
                slice_len++;
                ch += ch2;
                this.yytext += ch2;
                this.yyleng++;
                this.offset++;
                this.match += ch2;
                this.matched += ch2;
                if (this.options.ranges) {
                    this.yylloc.range[1]++;
                }
            }
        }
        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(slice_len);
        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 - len);
        this.matched = this.matched.substr(0, this.matched.length - len);

        if (lines.length - 1) {
            this.yylineno -= lines.length - 1;
        }

        this.yylloc.last_line = this.yylineno + 1;
        this.yylloc.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[1] = this.yylloc.range[0] + this.yyleng - len;
        }
        this.yyleng = this.yytext.length;
        this.done = false;
        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 {
            // when the parseError() call returns, we MUST ensure that the error is registered.
            // We accomplish this by signaling an 'error' token to be produced for the current
            // .lex() run.
            this._signaled_error_token = (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: this.match,
                token: null,
                line: this.yylineno,
                loc: this.yylloc,
                lexer: this
            }) || this.ERROR);
        }
        return this;
    },

// retain first n characters of the match
less:function (n) {
        this.unput(this.match.slice(n));
    },

// return (part of the) already matched input, i.e. for error messages
pastInput:function (maxSize) {
        var past = this.matched.substr(0, this.matched.length - this.match.length);
        if (maxSize < 0)
            maxSize = past.length;
        else if (!maxSize)
            maxSize = 20;
        return (past.length > maxSize ? '...' + past.substr(-maxSize) : past);
    },

// return (part of the) upcoming input, i.e. for error messages
upcomingInput:function (maxSize) {
        var next = this.match;
        if (maxSize < 0)
            maxSize = next.length + this._input.length;
        else if (!maxSize)
            maxSize = 20;
        if (next.length < maxSize) {
            next += this._input.substr(0, maxSize - next.length);
        }
        return (next.length > maxSize ? next.substr(0, maxSize) + '...' : next);
    },

// return a string which displays the character position where the lexing error occurred, i.e. for error messages
showPosition:function () {
        var pre = this.pastInput().replace(/\s/g, ' ');
        var c = new Array(pre.length + 1).join('-');
        return pre + this.upcomingInput().replace(/\s/g, ' ') + '\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.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.
        } else if (this._signaled_error_token) {
            // produce one 'error' token as .parseError() in reject() did not guarantee a failure signal by throwing an exception!
            token = this._signaled_error_token;
            this._signaled_error_token = false;
            return token;
        }
        return false;
    },

// return next match in input
next:function () {
        function clear() {
            this.yytext = '';
            this.yyleng = 0;
            this.match = '';
            this.matches = false;
            this._more = false;
            this._backtrack = false;
        }

        if (this.done) {
            clear.call(this);
            return this.EOF;
        }
        if (!this._input) {
            this.done = true;
        }

        var token,
            match,
            tempMatch,
            index;
        if (!this._more) {
            clear.call(this);
        }
        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 === '') {
            clear.call(this);
            this.done = true;
            return this.EOF;
        } else {
            token = this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                text: this.match + this._input,
                token: null,
                line: this.yylineno,
                loc: this.yylloc,
                lexer: this
            }) || this.ERROR;
            if (token === this.ERROR) {
                // we can try to recover from a lexer error that parseError() did not 'recover' for us, by moving forward at least one character at a time:
                if (!this.match.length) {
                    this.input();
                }
            }
            return token;
        }
    },

// return next match that has a token
lex:function lex() {
        var r;
        // allow the PRE/POST handlers set/modify the return token for maximum flexibility of the generated lexer:
        if (typeof this.options.pre_lex === 'function') {
            r = this.options.pre_lex.call(this);
        }
        while (!r) {
            r = this.next();
        }
        if (typeof this.options.post_lex === 'function') {
            // (also account for a userdef function which does not return any value: keep the token as is)
            r = this.options.post_lex.call(this, r) || r;
        }
        return r;
    },

// 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: {
  easy_keyword_rules: true,
  ranges: true
},
JisonLexerError: JisonLexerError,
performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {

var YYSTATE = YY_START;
switch($avoiding_name_collisions) {
case 0 : 
/*! Conditions:: token */ 
/*! Rule::       \r|\n */ 
 this.popState(); 
break;
case 1 : 
/*! Conditions:: token */ 
/*! Rule::       %% */ 
 this.popState(); 
break;
case 2 : 
/*! Conditions:: token */ 
/*! Rule::       ; */ 
 this.popState(); 
break;
case 3 : 
/*! Conditions:: bnf ebnf */ 
/*! Rule::       %% */ 
 this.pushState('code'); return 129; 
break;
case 11 : 
/*! Conditions:: options */ 
/*! Rule::       "(\\\\|\\"|[^"])*" */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yytext.length - 2); return 158; 
break;
case 12 : 
/*! Conditions:: options */ 
/*! Rule::       '(\\\\|\\'|[^'])*' */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yytext.length - 2); return 158; 
break;
case 14 : 
/*! Conditions:: options */ 
/*! Rule::       {BR}+ */ 
 this.popState(); return 155; 
break;
case 15 : 
/*! Conditions:: options */ 
/*! Rule::       \s+{BR}+ */ 
 this.popState(); return 155; 
break;
case 16 : 
/*! Conditions:: options */ 
/*! Rule::       \s+ */ 
 /* empty */ 
break;
case 17 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       \s+ */ 
 /* skip whitespace */ 
break;
case 18 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       \/\/.* */ 
 /* skip comment */ 
break;
case 19 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       \/\*(.|\n|\r)*?\*\/ */ 
 /* skip comment */ 
break;
case 20 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       \[{ID}\] */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); return 186; 
break;
case 22 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       "[^"]+" */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); return 152; 
break;
case 23 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       '[^']+' */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); return 152; 
break;
case 28 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       %% */ 
 this.pushState(ebnf ? 'ebnf' : 'bnf'); return 129; 
break;
case 29 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       %ebnf\b */ 
 if (!yy.options) { yy.options = {}; } ebnf = yy.options.ebnf = true; 
break;
case 30 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       %debug\b */ 
 if (!yy.options) { yy.options = {}; } yy.options.debug = true; 
break;
case 37 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       %token\b */ 
 this.pushState('token'); return 142; 
break;
case 39 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       %options\b */ 
 this.pushState('options'); return 153; 
break;
case 42 : 
/*! Conditions:: INITIAL ebnf bnf code */ 
/*! Rule::       %include\b */ 
 this.pushState('path'); return 193; 
break;
case 43 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       %{NAME}[^\r\n]* */ 
 
                                            /* ignore unrecognized decl */
                                            console.warn('ignoring unsupported parser option: ', yy_.yytext, ' while lexing in ', this.topState(), ' state');
                                            return 147;
                                         
break;
case 44 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       <{ID}> */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); return 171; 
break;
case 45 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       \{\{[\w\W]*?\}\} */ 
 yy_.yytext = yy_.yytext.substr(2, yy_.yyleng - 4); return 135; 
break;
case 46 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       %\{(.|\r|\n)*?%\} */ 
 yy_.yytext = yy_.yytext.substr(2, yy_.yytext.length - 4); return 135; 
break;
case 47 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       \{ */ 
 yy.depth = 0; this.pushState('action'); return 123; 
break;
case 48 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       ->.* */ 
 yy_.yytext = yy_.yytext.substr(2, yy_.yyleng - 2); return 189; 
break;
case 49 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       {HEX_NUMBER} */ 
 yy_.yytext = parseInt(yy_.yytext, 16); return 172; 
break;
case 50 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       {DECIMAL_NUMBER}(?![xX0-9a-fA-F]) */ 
 yy_.yytext = parseInt(yy_.yytext, 10); return 172; 
break;
case 51 : 
/*! Conditions:: bnf ebnf token INITIAL */ 
/*! Rule::       . */ 
 
                                            throw new Error("unsupported input character: " + yy_.yytext + " @ " + JSON.stringify(yy_.yylloc)); /* b0rk on bad characters */
                                         
break;
case 55 : 
/*! Conditions:: action */ 
/*! Rule::       \/[^ /]*?['"{}'][^ ]*?\/ */ 
 return 191; // regexp with braces or quotes (and no spaces) 
break;
case 60 : 
/*! Conditions:: action */ 
/*! Rule::       \{ */ 
 yy.depth++; return 123; 
break;
case 61 : 
/*! Conditions:: action */ 
/*! Rule::       \} */ 
 if (yy.depth === 0) { this.popState(); } else { yy.depth--; } return 125; 
break;
case 63 : 
/*! Conditions:: code */ 
/*! Rule::       [^\r\n]+ */ 
 return 196;      // the bit of CODE just before EOF... 
break;
case 64 : 
/*! Conditions:: path */ 
/*! Rule::       [\r\n] */ 
 this.popState(); this.unput(yy_.yytext); 
break;
case 65 : 
/*! Conditions:: path */ 
/*! Rule::       '[^\r\n]+' */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); this.popState(); return 194; 
break;
case 66 : 
/*! Conditions:: path */ 
/*! Rule::       "[^\r\n]+" */ 
 yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2); this.popState(); return 194; 
break;
case 67 : 
/*! Conditions:: path */ 
/*! Rule::       \s+ */ 
 // skip whitespace in the line 
break;
case 68 : 
/*! Conditions:: path */ 
/*! Rule::       [^\s\r\n]+ */ 
 this.popState(); return 194; 
break;
default:
  return this.simpleCaseActionClusters[$avoiding_name_collisions];
}
},
simpleCaseActionClusters: {

  /*! Conditions:: ebnf */ 
  /*! Rule::       \( */ 
   4 : 40,
  /*! Conditions:: ebnf */ 
  /*! Rule::       \) */ 
   5 : 41,
  /*! Conditions:: ebnf */ 
  /*! Rule::       \* */ 
   6 : 42,
  /*! Conditions:: ebnf */ 
  /*! Rule::       \? */ 
   7 : 63,
  /*! Conditions:: ebnf */ 
  /*! Rule::       \+ */ 
   8 : 43,
  /*! Conditions:: options */ 
  /*! Rule::       {NAME} */ 
   9 : 157,
  /*! Conditions:: options */ 
  /*! Rule::       = */ 
   10 : 61,
  /*! Conditions:: options */ 
  /*! Rule::       [^\s\r\n]+ */ 
   13 : 158,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       {ID} */ 
   21 : 151,
  /*! Conditions:: token */ 
  /*! Rule::       [^\s\r\n]+ */ 
   24 : 'TOKEN_WORD',
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       : */ 
   25 : 58,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       ; */ 
   26 : 59,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       \| */ 
   27 : 124,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %parser-type\b */ 
   31 : 161,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %prec\b */ 
   32 : 187,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %start\b */ 
   33 : 138,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %left\b */ 
   34 : 164,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %right\b */ 
   35 : 165,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %nonassoc\b */ 
   36 : 166,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %parse-param\b */ 
   38 : 159,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %lex[\w\W]*?{BR}\s*\/lex\b */ 
   40 : 140,
  /*! Conditions:: bnf ebnf token INITIAL */ 
  /*! Rule::       %import\b */ 
   41 : 148,
  /*! Conditions:: * */ 
  /*! Rule::       $ */ 
   52 : 132,
  /*! Conditions:: action */ 
  /*! Rule::       \/\*(.|\n|\r)*?\*\/ */ 
   53 : 191,
  /*! Conditions:: action */ 
  /*! Rule::       \/\/.* */ 
   54 : 191,
  /*! Conditions:: action */ 
  /*! Rule::       "(\\\\|\\"|[^"])*" */ 
   56 : 191,
  /*! Conditions:: action */ 
  /*! Rule::       '(\\\\|\\'|[^'])*' */ 
   57 : 191,
  /*! Conditions:: action */ 
  /*! Rule::       [/"'][^{}/"']+ */ 
   58 : 191,
  /*! Conditions:: action */ 
  /*! Rule::       [^{}/"']+ */ 
   59 : 191,
  /*! Conditions:: code */ 
  /*! Rule::       [^\r\n]*(\r|\n)+ */ 
   62 : 196
},
rules: [
/^(?:\r|\n)/,
/^(?:%%)/,
/^(?:;)/,
/^(?:%%)/,
/^(?:\()/,
/^(?:\))/,
/^(?:\*)/,
/^(?:\?)/,
/^(?:\+)/,
/^(?:([a-zA-Z_](?:[a-zA-Z0-9_-]*[a-zA-Z0-9_])?))/,
/^(?:=)/,
/^(?:"(\\\\|\\"|[^"])*")/,
/^(?:'(\\\\|\\'|[^'])*')/,
/^(?:[^\s\r\n]+)/,
/^(?:(\r\n|\n|\r)+)/,
/^(?:\s+(\r\n|\n|\r)+)/,
/^(?:\s+)/,
/^(?:\s+)/,
/^(?:\/\/.*)/,
/^(?:\/\*(.|\n|\r)*?\*\/)/,
/^(?:\[([a-zA-Z_][a-zA-Z0-9_]*)\])/,
/^(?:([a-zA-Z_][a-zA-Z0-9_]*))/,
/^(?:"[^"]+")/,
/^(?:'[^']+')/,
/^(?:[^\s\r\n]+)/,
/^(?::)/,
/^(?:;)/,
/^(?:\|)/,
/^(?:%%)/,
/^(?:%ebnf\b)/,
/^(?:%debug\b)/,
/^(?:%parser-type\b)/,
/^(?:%prec\b)/,
/^(?:%start\b)/,
/^(?:%left\b)/,
/^(?:%right\b)/,
/^(?:%nonassoc\b)/,
/^(?:%token\b)/,
/^(?:%parse-param\b)/,
/^(?:%options\b)/,
/^(?:%lex[\w\W]*?(\r\n|\n|\r)\s*\/lex\b)/,
/^(?:%import\b)/,
/^(?:%include\b)/,
/^(?:%([a-zA-Z_](?:[a-zA-Z0-9_-]*[a-zA-Z0-9_])?)[^\r\n]*)/,
/^(?:<([a-zA-Z_][a-zA-Z0-9_]*)>)/,
/^(?:\{\{[\w\W]*?\}\})/,
/^(?:%\{(.|\r|\n)*?%\})/,
/^(?:\{)/,
/^(?:->.*)/,
/^(?:(0[xX][0-9a-fA-F]+))/,
/^(?:([1-9][0-9]*)(?![xX0-9a-fA-F]))/,
/^(?:.)/,
/^(?:$)/,
/^(?:\/\*(.|\n|\r)*?\*\/)/,
/^(?:\/\/.*)/,
/^(?:\/[^ \/]*?['"{}'][^ ]*?\/)/,
/^(?:"(\\\\|\\"|[^"])*")/,
/^(?:'(\\\\|\\'|[^'])*')/,
/^(?:[\/"'][^{}\/"']+)/,
/^(?:[^{}\/"']+)/,
/^(?:\{)/,
/^(?:\})/,
/^(?:[^\r\n]*(\r|\n)+)/,
/^(?:[^\r\n]+)/,
/^(?:[\r\n])/,
/^(?:'[^\r\n]+')/,
/^(?:"[^\r\n]+")/,
/^(?:\s+)/,
/^(?:[^\s\r\n]+)/
],
conditions: {
  "bnf": {
    rules: [
      3,
      17,
      18,
      19,
      20,
      21,
      22,
      23,
      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
    ],
    inclusive: true
  },
  "ebnf": {
    rules: [
      3,
      4,
      5,
      6,
      7,
      8,
      17,
      18,
      19,
      20,
      21,
      22,
      23,
      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
    ],
    inclusive: true
  },
  "token": {
    rules: [
      0,
      1,
      2,
      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,
      43,
      44,
      45,
      46,
      47,
      48,
      49,
      50,
      51,
      52
    ],
    inclusive: true
  },
  "action": {
    rules: [
      52,
      53,
      54,
      55,
      56,
      57,
      58,
      59,
      60,
      61
    ],
    inclusive: false
  },
  "code": {
    rules: [
      42,
      52,
      62,
      63
    ],
    inclusive: false
  },
  "path": {
    rules: [
      52,
      64,
      65,
      66,
      67,
      68
    ],
    inclusive: false
  },
  "options": {
    rules: [
      9,
      10,
      11,
      12,
      13,
      14,
      15,
      16,
      52
    ],
    inclusive: false
  },
  "INITIAL": {
    rules: [
      17,
      18,
      19,
      20,
      21,
      22,
      23,
      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
    ],
    inclusive: true
  }
}
};

// lexer.JisonLexerError = JisonLexerError;
return lexer;
})();
parser.lexer = lexer;

function Parser () {
  this.yy = {};
}
Parser.prototype = parser;
parser.Parser = Parser;
// parser.JisonParserError = JisonParserError;

return new Parser();
})();




if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
exports.parser = bnf;
exports.Parser = bnf.Parser;
exports.parse = function () {
  return bnf.parse.apply(bnf, arguments);
};

}