How to use matchTokenAt_14 method in Cucumber-gherkin

1// This file is generated. Do not edit! Edit gherkin-javascript.razor instead.
2var Errors = require('./errors');
3
4module.exports = function Parser() {
5
6  var RULE_TYPES = [
7    'None',
8    '_EOF', // #EOF
9    '_Empty', // #Empty
10    '_Comment', // #Comment
11    '_TagLine', // #TagLine
12    '_FeatureLine', // #FeatureLine
13    '_BackgroundLine', // #BackgroundLine
14    '_ScenarioLine', // #ScenarioLine
15    '_ScenarioOutlineLine', // #ScenarioOutlineLine
16    '_ExamplesLine', // #ExamplesLine
17    '_StepLine', // #StepLine
18    '_DocStringSeparator', // #DocStringSeparator
19    '_TableRow', // #TableRow
20    '_Language', // #Language
21    '_Other', // #Other
22    'Feature', // Feature! := Feature_Header Background? Scenario_Definition*
23    'Feature_Header', // Feature_Header! := #Language? Tags? #FeatureLine Feature_Description
24    'Background', // Background! := #BackgroundLine Background_Description Scenario_Step*
25    'Scenario_Definition', // Scenario_Definition! := Tags? (Scenario | ScenarioOutline)
26    'Scenario', // Scenario! := #ScenarioLine Scenario_Description Scenario_Step*
27    'ScenarioOutline', // ScenarioOutline! := #ScenarioOutlineLine ScenarioOutline_Description ScenarioOutline_Step* Examples+
28    'Examples', // Examples! [#Empty|#Comment|#TagLine->#ExamplesLine] := Tags? #ExamplesLine Examples_Description Examples_Table
29    'Examples_Table', // Examples_Table := #TableRow+
30    'Scenario_Step', // Scenario_Step := Step
31    'ScenarioOutline_Step', // ScenarioOutline_Step := Step
32    'Step', // Step! := #StepLine Step_Arg?
33    'Step_Arg', // Step_Arg := (DataTable | DocString)
34    'DataTable', // DataTable! := #TableRow+
35    'DocString', // DocString! := #DocStringSeparator #Other* #DocStringSeparator
36    'Tags', // Tags! := #TagLine+
37    'Feature_Description', // Feature_Description := Description_Helper
38    'Background_Description', // Background_Description := Description_Helper
39    'Scenario_Description', // Scenario_Description := Description_Helper
40    'ScenarioOutline_Description', // ScenarioOutline_Description := Description_Helper
41    'Examples_Description', // Examples_Description := Description_Helper
42    'Description_Helper', // Description_Helper := #Empty* Description? #Comment*
43    'Description', // Description! := #Other+
44  ]
45
46  var context = {};
47
48  this.parse = function(tokenScanner, astBuilder, tokenMatcher) {
49    context.tokenScanner = tokenScanner;
50    context.astBuilder = astBuilder;
51    context.tokenMatcher = tokenMatcher;
52    context.tokenQueue = [];
53    context.errors = [];
54
55    startRule(context, 'Feature');
56    var state = 0;
57    var token = null;
58    while(true) {
59      token = readToken(context);
60      state = matchToken(state, token, context);
61      if(token.isEof) break;
62    }
63
64    endRule(context, 'Feature');
65
66    // TODO: Similar optimisation in C#/Java/JavaScript
67    if(context.errors.length == 1) {
68      throw context.errors[0];
69    } else if(context.errors.length > 1) {
70      throw Errors.CompositeParserException.create(context.errors);
71    }
72
73    return getResult(context);
74  };
75
76  function addError(context, error) {
77    context.errors.push(error);
78    if (context.errors.length > 10)
79      throw Errors.CompositeParserException.create(context.errors);
80  }
81
82  function startRule(context, ruleType) {
83    handleAstError(context, function () {
84      context.astBuilder.startRule(ruleType);
85    });
86  }
87
88  function endRule(context, ruleType) {
89    handleAstError(context, function () {
90      context.astBuilder.endRule(ruleType);
91    });
92  }
93
94  function build(context, token) {
95    handleAstError(context, function () {
96      context.astBuilder.build(token);
97    });
98  }
99
100  function getResult(context) {
101    return context.astBuilder.getResult();
102  }
103
104  function handleAstError(context, action) {
105    handleExternalError(context, true, action)
106  }
107
108  function handleExternalError(context, defaultValue, action) {
109    if(this.stopAtFirstError) return action();
110    try {
111      return action();
112    } catch (e) {
113      if(e instanceof Errors.CompositeParserException) {
114        e.errors.forEach(function (error) {
115          addError(context, error);
116        });
117      } else if(e instanceof Errors.ParserException) {
118        addError(context, e);
119      } else {
120        throw e;
121      }
122    }
123    return defaultValue;
124  }
125
126  function readToken(context) {
127    return context.tokenQueue.length > 0 ?
128      context.tokenQueue.shift() :
129      context.tokenScanner.read();
130  }
131
132  function matchToken(state, token, context) {
133    switch(state) {
134    case 0:
135      return matchTokenAt_0(token, context);
136    case 1:
137      return matchTokenAt_1(token, context);
138    case 2:
139      return matchTokenAt_2(token, context);
140    case 3:
141      return matchTokenAt_3(token, context);
142    case 4:
143      return matchTokenAt_4(token, context);
144    case 5:
145      return matchTokenAt_5(token, context);
146    case 6:
147      return matchTokenAt_6(token, context);
148    case 7:
149      return matchTokenAt_7(token, context);
150    case 8:
151      return matchTokenAt_8(token, context);
152    case 9:
153      return matchTokenAt_9(token, context);
154    case 10:
155      return matchTokenAt_10(token, context);
156    case 11:
157      return matchTokenAt_11(token, context);
158    case 12:
159      return matchTokenAt_12(token, context);
160    case 13:
161      return matchTokenAt_13(token, context);
162    case 14:
163      return matchTokenAt_14(token, context);
164    case 15:
165      return matchTokenAt_15(token, context);
166    case 16:
167      return matchTokenAt_16(token, context);
168    case 17:
169      return matchTokenAt_17(token, context);
170    case 18:
171      return matchTokenAt_18(token, context);
172    case 19:
173      return matchTokenAt_19(token, context);
174    case 20:
175      return matchTokenAt_20(token, context);
176    case 21:
177      return matchTokenAt_21(token, context);
178    case 22:
179      return matchTokenAt_22(token, context);
180    case 23:
181      return matchTokenAt_23(token, context);
182    case 24:
183      return matchTokenAt_24(token, context);
184    case 25:
185      return matchTokenAt_25(token, context);
186    case 26:
187      return matchTokenAt_26(token, context);
188    case 28:
189      return matchTokenAt_28(token, context);
190    case 29:
191      return matchTokenAt_29(token, context);
192    case 30:
193      return matchTokenAt_30(token, context);
194    case 31:
195      return matchTokenAt_31(token, context);
196    case 32:
197      return matchTokenAt_32(token, context);
198    case 33:
199      return matchTokenAt_33(token, context);
200    default:
201      throw new Error("Unknown state: " + state);
202    }
203  }
204
205
206  // Start
207  function matchTokenAt_0(token, context) {
208    if(match_Language(context, token)) {
209      startRule(context, 'Feature_Header');
210      build(context, token);
211      return 1;
212    }
213    if(match_TagLine(context, token)) {
214      startRule(context, 'Feature_Header');
215      startRule(context, 'Tags');
216      build(context, token);
217      return 2;
218    }
219    if(match_FeatureLine(context, token)) {
220      startRule(context, 'Feature_Header');
221      build(context, token);
222      return 3;
223    }
224    if(match_Comment(context, token)) {
225      build(context, token);
226      return 0;
227    }
228    if(match_Empty(context, token)) {
229      build(context, token);
230      return 0;
231    }
232    
233    var stateComment = "State: 0 - Start";
234    token.detach();
235    var expectedTokens = ["#Language", "#TagLine", "#FeatureLine", "#Comment", "#Empty"];
236    var error = token.isEof ?
237      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
238      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
239    if (this.stopAtFirstError) throw error;
240    addError(context, error);
241    return 0;
242  }
243
244
245  // Feature:0>Feature_Header:0>#Language:0
246  function matchTokenAt_1(token, context) {
247    if(match_TagLine(context, token)) {
248      startRule(context, 'Tags');
249      build(context, token);
250      return 2;
251    }
252    if(match_FeatureLine(context, token)) {
253      build(context, token);
254      return 3;
255    }
256    if(match_Comment(context, token)) {
257      build(context, token);
258      return 1;
259    }
260    if(match_Empty(context, token)) {
261      build(context, token);
262      return 1;
263    }
264    
265    var stateComment = "State: 1 - Feature:0>Feature_Header:0>#Language:0";
266    token.detach();
267    var expectedTokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"];
268    var error = token.isEof ?
269      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
270      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
271    if (this.stopAtFirstError) throw error;
272    addError(context, error);
273    return 1;
274  }
275
276
277  // Feature:0>Feature_Header:1>Tags:0>#TagLine:0
278  function matchTokenAt_2(token, context) {
279    if(match_TagLine(context, token)) {
280      build(context, token);
281      return 2;
282    }
283    if(match_FeatureLine(context, token)) {
284      endRule(context, 'Tags');
285      build(context, token);
286      return 3;
287    }
288    if(match_Comment(context, token)) {
289      build(context, token);
290      return 2;
291    }
292    if(match_Empty(context, token)) {
293      build(context, token);
294      return 2;
295    }
296    
297    var stateComment = "State: 2 - Feature:0>Feature_Header:1>Tags:0>#TagLine:0";
298    token.detach();
299    var expectedTokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"];
300    var error = token.isEof ?
301      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
302      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
303    if (this.stopAtFirstError) throw error;
304    addError(context, error);
305    return 2;
306  }
307
308
309  // Feature:0>Feature_Header:2>#FeatureLine:0
310  function matchTokenAt_3(token, context) {
311    if(match_EOF(context, token)) {
312      endRule(context, 'Feature_Header');
313      build(context, token);
314      return 27;
315    }
316    if(match_Empty(context, token)) {
317      build(context, token);
318      return 3;
319    }
320    if(match_Comment(context, token)) {
321      build(context, token);
322      return 5;
323    }
324    if(match_BackgroundLine(context, token)) {
325      endRule(context, 'Feature_Header');
326      startRule(context, 'Background');
327      build(context, token);
328      return 6;
329    }
330    if(match_TagLine(context, token)) {
331      endRule(context, 'Feature_Header');
332      startRule(context, 'Scenario_Definition');
333      startRule(context, 'Tags');
334      build(context, token);
335      return 11;
336    }
337    if(match_ScenarioLine(context, token)) {
338      endRule(context, 'Feature_Header');
339      startRule(context, 'Scenario_Definition');
340      startRule(context, 'Scenario');
341      build(context, token);
342      return 12;
343    }
344    if(match_ScenarioOutlineLine(context, token)) {
345      endRule(context, 'Feature_Header');
346      startRule(context, 'Scenario_Definition');
347      startRule(context, 'ScenarioOutline');
348      build(context, token);
349      return 17;
350    }
351    if(match_Other(context, token)) {
352      startRule(context, 'Description');
353      build(context, token);
354      return 4;
355    }
356    
357    var stateComment = "State: 3 - Feature:0>Feature_Header:2>#FeatureLine:0";
358    token.detach();
359    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
360    var error = token.isEof ?
361      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
362      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
363    if (this.stopAtFirstError) throw error;
364    addError(context, error);
365    return 3;
366  }
367
368
369  // Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:1>Description:0>#Other:0
370  function matchTokenAt_4(token, context) {
371    if(match_EOF(context, token)) {
372      endRule(context, 'Description');
373      endRule(context, 'Feature_Header');
374      build(context, token);
375      return 27;
376    }
377    if(match_Comment(context, token)) {
378      endRule(context, 'Description');
379      build(context, token);
380      return 5;
381    }
382    if(match_BackgroundLine(context, token)) {
383      endRule(context, 'Description');
384      endRule(context, 'Feature_Header');
385      startRule(context, 'Background');
386      build(context, token);
387      return 6;
388    }
389    if(match_TagLine(context, token)) {
390      endRule(context, 'Description');
391      endRule(context, 'Feature_Header');
392      startRule(context, 'Scenario_Definition');
393      startRule(context, 'Tags');
394      build(context, token);
395      return 11;
396    }
397    if(match_ScenarioLine(context, token)) {
398      endRule(context, 'Description');
399      endRule(context, 'Feature_Header');
400      startRule(context, 'Scenario_Definition');
401      startRule(context, 'Scenario');
402      build(context, token);
403      return 12;
404    }
405    if(match_ScenarioOutlineLine(context, token)) {
406      endRule(context, 'Description');
407      endRule(context, 'Feature_Header');
408      startRule(context, 'Scenario_Definition');
409      startRule(context, 'ScenarioOutline');
410      build(context, token);
411      return 17;
412    }
413    if(match_Other(context, token)) {
414      build(context, token);
415      return 4;
416    }
417    
418    var stateComment = "State: 4 - Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:1>Description:0>#Other:0";
419    token.detach();
420    var expectedTokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
421    var error = token.isEof ?
422      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
423      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
424    if (this.stopAtFirstError) throw error;
425    addError(context, error);
426    return 4;
427  }
428
429
430  // Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:2>#Comment:0
431  function matchTokenAt_5(token, context) {
432    if(match_EOF(context, token)) {
433      endRule(context, 'Feature_Header');
434      build(context, token);
435      return 27;
436    }
437    if(match_Comment(context, token)) {
438      build(context, token);
439      return 5;
440    }
441    if(match_BackgroundLine(context, token)) {
442      endRule(context, 'Feature_Header');
443      startRule(context, 'Background');
444      build(context, token);
445      return 6;
446    }
447    if(match_TagLine(context, token)) {
448      endRule(context, 'Feature_Header');
449      startRule(context, 'Scenario_Definition');
450      startRule(context, 'Tags');
451      build(context, token);
452      return 11;
453    }
454    if(match_ScenarioLine(context, token)) {
455      endRule(context, 'Feature_Header');
456      startRule(context, 'Scenario_Definition');
457      startRule(context, 'Scenario');
458      build(context, token);
459      return 12;
460    }
461    if(match_ScenarioOutlineLine(context, token)) {
462      endRule(context, 'Feature_Header');
463      startRule(context, 'Scenario_Definition');
464      startRule(context, 'ScenarioOutline');
465      build(context, token);
466      return 17;
467    }
468    if(match_Empty(context, token)) {
469      build(context, token);
470      return 5;
471    }
472    
473    var stateComment = "State: 5 - Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:2>#Comment:0";
474    token.detach();
475    var expectedTokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
476    var error = token.isEof ?
477      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
478      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
479    if (this.stopAtFirstError) throw error;
480    addError(context, error);
481    return 5;
482  }
483
484
485  // Feature:1>Background:0>#BackgroundLine:0
486  function matchTokenAt_6(token, context) {
487    if(match_EOF(context, token)) {
488      endRule(context, 'Background');
489      build(context, token);
490      return 27;
491    }
492    if(match_Empty(context, token)) {
493      build(context, token);
494      return 6;
495    }
496    if(match_Comment(context, token)) {
497      build(context, token);
498      return 8;
499    }
500    if(match_StepLine(context, token)) {
501      startRule(context, 'Step');
502      build(context, token);
503      return 9;
504    }
505    if(match_TagLine(context, token)) {
506      endRule(context, 'Background');
507      startRule(context, 'Scenario_Definition');
508      startRule(context, 'Tags');
509      build(context, token);
510      return 11;
511    }
512    if(match_ScenarioLine(context, token)) {
513      endRule(context, 'Background');
514      startRule(context, 'Scenario_Definition');
515      startRule(context, 'Scenario');
516      build(context, token);
517      return 12;
518    }
519    if(match_ScenarioOutlineLine(context, token)) {
520      endRule(context, 'Background');
521      startRule(context, 'Scenario_Definition');
522      startRule(context, 'ScenarioOutline');
523      build(context, token);
524      return 17;
525    }
526    if(match_Other(context, token)) {
527      startRule(context, 'Description');
528      build(context, token);
529      return 7;
530    }
531    
532    var stateComment = "State: 6 - Feature:1>Background:0>#BackgroundLine:0";
533    token.detach();
534    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
535    var error = token.isEof ?
536      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
537      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
538    if (this.stopAtFirstError) throw error;
539    addError(context, error);
540    return 6;
541  }
542
543
544  // Feature:1>Background:1>Background_Description:0>Description_Helper:1>Description:0>#Other:0
545  function matchTokenAt_7(token, context) {
546    if(match_EOF(context, token)) {
547      endRule(context, 'Description');
548      endRule(context, 'Background');
549      build(context, token);
550      return 27;
551    }
552    if(match_Comment(context, token)) {
553      endRule(context, 'Description');
554      build(context, token);
555      return 8;
556    }
557    if(match_StepLine(context, token)) {
558      endRule(context, 'Description');
559      startRule(context, 'Step');
560      build(context, token);
561      return 9;
562    }
563    if(match_TagLine(context, token)) {
564      endRule(context, 'Description');
565      endRule(context, 'Background');
566      startRule(context, 'Scenario_Definition');
567      startRule(context, 'Tags');
568      build(context, token);
569      return 11;
570    }
571    if(match_ScenarioLine(context, token)) {
572      endRule(context, 'Description');
573      endRule(context, 'Background');
574      startRule(context, 'Scenario_Definition');
575      startRule(context, 'Scenario');
576      build(context, token);
577      return 12;
578    }
579    if(match_ScenarioOutlineLine(context, token)) {
580      endRule(context, 'Description');
581      endRule(context, 'Background');
582      startRule(context, 'Scenario_Definition');
583      startRule(context, 'ScenarioOutline');
584      build(context, token);
585      return 17;
586    }
587    if(match_Other(context, token)) {
588      build(context, token);
589      return 7;
590    }
591    
592    var stateComment = "State: 7 - Feature:1>Background:1>Background_Description:0>Description_Helper:1>Description:0>#Other:0";
593    token.detach();
594    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
595    var error = token.isEof ?
596      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
597      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
598    if (this.stopAtFirstError) throw error;
599    addError(context, error);
600    return 7;
601  }
602
603
604  // Feature:1>Background:1>Background_Description:0>Description_Helper:2>#Comment:0
605  function matchTokenAt_8(token, context) {
606    if(match_EOF(context, token)) {
607      endRule(context, 'Background');
608      build(context, token);
609      return 27;
610    }
611    if(match_Comment(context, token)) {
612      build(context, token);
613      return 8;
614    }
615    if(match_StepLine(context, token)) {
616      startRule(context, 'Step');
617      build(context, token);
618      return 9;
619    }
620    if(match_TagLine(context, token)) {
621      endRule(context, 'Background');
622      startRule(context, 'Scenario_Definition');
623      startRule(context, 'Tags');
624      build(context, token);
625      return 11;
626    }
627    if(match_ScenarioLine(context, token)) {
628      endRule(context, 'Background');
629      startRule(context, 'Scenario_Definition');
630      startRule(context, 'Scenario');
631      build(context, token);
632      return 12;
633    }
634    if(match_ScenarioOutlineLine(context, token)) {
635      endRule(context, 'Background');
636      startRule(context, 'Scenario_Definition');
637      startRule(context, 'ScenarioOutline');
638      build(context, token);
639      return 17;
640    }
641    if(match_Empty(context, token)) {
642      build(context, token);
643      return 8;
644    }
645    
646    var stateComment = "State: 8 - Feature:1>Background:1>Background_Description:0>Description_Helper:2>#Comment:0";
647    token.detach();
648    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
649    var error = token.isEof ?
650      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
651      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
652    if (this.stopAtFirstError) throw error;
653    addError(context, error);
654    return 8;
655  }
656
657
658  // Feature:1>Background:2>Scenario_Step:0>Step:0>#StepLine:0
659  function matchTokenAt_9(token, context) {
660    if(match_EOF(context, token)) {
661      endRule(context, 'Step');
662      endRule(context, 'Background');
663      build(context, token);
664      return 27;
665    }
666    if(match_TableRow(context, token)) {
667      startRule(context, 'DataTable');
668      build(context, token);
669      return 10;
670    }
671    if(match_DocStringSeparator(context, token)) {
672      startRule(context, 'DocString');
673      build(context, token);
674      return 32;
675    }
676    if(match_StepLine(context, token)) {
677      endRule(context, 'Step');
678      startRule(context, 'Step');
679      build(context, token);
680      return 9;
681    }
682    if(match_TagLine(context, token)) {
683      endRule(context, 'Step');
684      endRule(context, 'Background');
685      startRule(context, 'Scenario_Definition');
686      startRule(context, 'Tags');
687      build(context, token);
688      return 11;
689    }
690    if(match_ScenarioLine(context, token)) {
691      endRule(context, 'Step');
692      endRule(context, 'Background');
693      startRule(context, 'Scenario_Definition');
694      startRule(context, 'Scenario');
695      build(context, token);
696      return 12;
697    }
698    if(match_ScenarioOutlineLine(context, token)) {
699      endRule(context, 'Step');
700      endRule(context, 'Background');
701      startRule(context, 'Scenario_Definition');
702      startRule(context, 'ScenarioOutline');
703      build(context, token);
704      return 17;
705    }
706    if(match_Comment(context, token)) {
707      build(context, token);
708      return 9;
709    }
710    if(match_Empty(context, token)) {
711      build(context, token);
712      return 9;
713    }
714    
715    var stateComment = "State: 9 - Feature:1>Background:2>Scenario_Step:0>Step:0>#StepLine:0";
716    token.detach();
717    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
718    var error = token.isEof ?
719      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
720      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
721    if (this.stopAtFirstError) throw error;
722    addError(context, error);
723    return 9;
724  }
725
726
727  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
728  function matchTokenAt_10(token, context) {
729    if(match_EOF(context, token)) {
730      endRule(context, 'DataTable');
731      endRule(context, 'Step');
732      endRule(context, 'Background');
733      build(context, token);
734      return 27;
735    }
736    if(match_TableRow(context, token)) {
737      build(context, token);
738      return 10;
739    }
740    if(match_StepLine(context, token)) {
741      endRule(context, 'DataTable');
742      endRule(context, 'Step');
743      startRule(context, 'Step');
744      build(context, token);
745      return 9;
746    }
747    if(match_TagLine(context, token)) {
748      endRule(context, 'DataTable');
749      endRule(context, 'Step');
750      endRule(context, 'Background');
751      startRule(context, 'Scenario_Definition');
752      startRule(context, 'Tags');
753      build(context, token);
754      return 11;
755    }
756    if(match_ScenarioLine(context, token)) {
757      endRule(context, 'DataTable');
758      endRule(context, 'Step');
759      endRule(context, 'Background');
760      startRule(context, 'Scenario_Definition');
761      startRule(context, 'Scenario');
762      build(context, token);
763      return 12;
764    }
765    if(match_ScenarioOutlineLine(context, token)) {
766      endRule(context, 'DataTable');
767      endRule(context, 'Step');
768      endRule(context, 'Background');
769      startRule(context, 'Scenario_Definition');
770      startRule(context, 'ScenarioOutline');
771      build(context, token);
772      return 17;
773    }
774    if(match_Comment(context, token)) {
775      build(context, token);
776      return 10;
777    }
778    if(match_Empty(context, token)) {
779      build(context, token);
780      return 10;
781    }
782    
783    var stateComment = "State: 10 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
784    token.detach();
785    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
786    var error = token.isEof ?
787      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
788      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
789    if (this.stopAtFirstError) throw error;
790    addError(context, error);
791    return 10;
792  }
793
794
795  // Feature:2>Scenario_Definition:0>Tags:0>#TagLine:0
796  function matchTokenAt_11(token, context) {
797    if(match_TagLine(context, token)) {
798      build(context, token);
799      return 11;
800    }
801    if(match_ScenarioLine(context, token)) {
802      endRule(context, 'Tags');
803      startRule(context, 'Scenario');
804      build(context, token);
805      return 12;
806    }
807    if(match_ScenarioOutlineLine(context, token)) {
808      endRule(context, 'Tags');
809      startRule(context, 'ScenarioOutline');
810      build(context, token);
811      return 17;
812    }
813    if(match_Comment(context, token)) {
814      build(context, token);
815      return 11;
816    }
817    if(match_Empty(context, token)) {
818      build(context, token);
819      return 11;
820    }
821    
822    var stateComment = "State: 11 - Feature:2>Scenario_Definition:0>Tags:0>#TagLine:0";
823    token.detach();
824    var expectedTokens = ["#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
825    var error = token.isEof ?
826      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
827      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
828    if (this.stopAtFirstError) throw error;
829    addError(context, error);
830    return 11;
831  }
832
833
834  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:0>#ScenarioLine:0
835  function matchTokenAt_12(token, context) {
836    if(match_EOF(context, token)) {
837      endRule(context, 'Scenario');
838      endRule(context, 'Scenario_Definition');
839      build(context, token);
840      return 27;
841    }
842    if(match_Empty(context, token)) {
843      build(context, token);
844      return 12;
845    }
846    if(match_Comment(context, token)) {
847      build(context, token);
848      return 14;
849    }
850    if(match_StepLine(context, token)) {
851      startRule(context, 'Step');
852      build(context, token);
853      return 15;
854    }
855    if(match_TagLine(context, token)) {
856      endRule(context, 'Scenario');
857      endRule(context, 'Scenario_Definition');
858      startRule(context, 'Scenario_Definition');
859      startRule(context, 'Tags');
860      build(context, token);
861      return 11;
862    }
863    if(match_ScenarioLine(context, token)) {
864      endRule(context, 'Scenario');
865      endRule(context, 'Scenario_Definition');
866      startRule(context, 'Scenario_Definition');
867      startRule(context, 'Scenario');
868      build(context, token);
869      return 12;
870    }
871    if(match_ScenarioOutlineLine(context, token)) {
872      endRule(context, 'Scenario');
873      endRule(context, 'Scenario_Definition');
874      startRule(context, 'Scenario_Definition');
875      startRule(context, 'ScenarioOutline');
876      build(context, token);
877      return 17;
878    }
879    if(match_Other(context, token)) {
880      startRule(context, 'Description');
881      build(context, token);
882      return 13;
883    }
884    
885    var stateComment = "State: 12 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:0>#ScenarioLine:0";
886    token.detach();
887    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
888    var error = token.isEof ?
889      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
890      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
891    if (this.stopAtFirstError) throw error;
892    addError(context, error);
893    return 12;
894  }
895
896
897  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0
898  function matchTokenAt_13(token, context) {
899    if(match_EOF(context, token)) {
900      endRule(context, 'Description');
901      endRule(context, 'Scenario');
902      endRule(context, 'Scenario_Definition');
903      build(context, token);
904      return 27;
905    }
906    if(match_Comment(context, token)) {
907      endRule(context, 'Description');
908      build(context, token);
909      return 14;
910    }
911    if(match_StepLine(context, token)) {
912      endRule(context, 'Description');
913      startRule(context, 'Step');
914      build(context, token);
915      return 15;
916    }
917    if(match_TagLine(context, token)) {
918      endRule(context, 'Description');
919      endRule(context, 'Scenario');
920      endRule(context, 'Scenario_Definition');
921      startRule(context, 'Scenario_Definition');
922      startRule(context, 'Tags');
923      build(context, token);
924      return 11;
925    }
926    if(match_ScenarioLine(context, token)) {
927      endRule(context, 'Description');
928      endRule(context, 'Scenario');
929      endRule(context, 'Scenario_Definition');
930      startRule(context, 'Scenario_Definition');
931      startRule(context, 'Scenario');
932      build(context, token);
933      return 12;
934    }
935    if(match_ScenarioOutlineLine(context, token)) {
936      endRule(context, 'Description');
937      endRule(context, 'Scenario');
938      endRule(context, 'Scenario_Definition');
939      startRule(context, 'Scenario_Definition');
940      startRule(context, 'ScenarioOutline');
941      build(context, token);
942      return 17;
943    }
944    if(match_Other(context, token)) {
945      build(context, token);
946      return 13;
947    }
948    
949    var stateComment = "State: 13 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0";
950    token.detach();
951    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
952    var error = token.isEof ?
953      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
954      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
955    if (this.stopAtFirstError) throw error;
956    addError(context, error);
957    return 13;
958  }
959
960
961  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0
962  function matchTokenAt_14(token, context) {
963    if(match_EOF(context, token)) {
964      endRule(context, 'Scenario');
965      endRule(context, 'Scenario_Definition');
966      build(context, token);
967      return 27;
968    }
969    if(match_Comment(context, token)) {
970      build(context, token);
971      return 14;
972    }
973    if(match_StepLine(context, token)) {
974      startRule(context, 'Step');
975      build(context, token);
976      return 15;
977    }
978    if(match_TagLine(context, token)) {
979      endRule(context, 'Scenario');
980      endRule(context, 'Scenario_Definition');
981      startRule(context, 'Scenario_Definition');
982      startRule(context, 'Tags');
983      build(context, token);
984      return 11;
985    }
986    if(match_ScenarioLine(context, token)) {
987      endRule(context, 'Scenario');
988      endRule(context, 'Scenario_Definition');
989      startRule(context, 'Scenario_Definition');
990      startRule(context, 'Scenario');
991      build(context, token);
992      return 12;
993    }
994    if(match_ScenarioOutlineLine(context, token)) {
995      endRule(context, 'Scenario');
996      endRule(context, 'Scenario_Definition');
997      startRule(context, 'Scenario_Definition');
998      startRule(context, 'ScenarioOutline');
999      build(context, token);
1000      return 17;
1001    }
1002    if(match_Empty(context, token)) {
1003      build(context, token);
1004      return 14;
1005    }
1006    
1007    var stateComment = "State: 14 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0";
1008    token.detach();
1009    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
1010    var error = token.isEof ?
1011      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1012      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1013    if (this.stopAtFirstError) throw error;
1014    addError(context, error);
1015    return 14;
1016  }
1017
1018
1019  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0
1020  function matchTokenAt_15(token, context) {
1021    if(match_EOF(context, token)) {
1022      endRule(context, 'Step');
1023      endRule(context, 'Scenario');
1024      endRule(context, 'Scenario_Definition');
1025      build(context, token);
1026      return 27;
1027    }
1028    if(match_TableRow(context, token)) {
1029      startRule(context, 'DataTable');
1030      build(context, token);
1031      return 16;
1032    }
1033    if(match_DocStringSeparator(context, token)) {
1034      startRule(context, 'DocString');
1035      build(context, token);
1036      return 30;
1037    }
1038    if(match_StepLine(context, token)) {
1039      endRule(context, 'Step');
1040      startRule(context, 'Step');
1041      build(context, token);
1042      return 15;
1043    }
1044    if(match_TagLine(context, token)) {
1045      endRule(context, 'Step');
1046      endRule(context, 'Scenario');
1047      endRule(context, 'Scenario_Definition');
1048      startRule(context, 'Scenario_Definition');
1049      startRule(context, 'Tags');
1050      build(context, token);
1051      return 11;
1052    }
1053    if(match_ScenarioLine(context, token)) {
1054      endRule(context, 'Step');
1055      endRule(context, 'Scenario');
1056      endRule(context, 'Scenario_Definition');
1057      startRule(context, 'Scenario_Definition');
1058      startRule(context, 'Scenario');
1059      build(context, token);
1060      return 12;
1061    }
1062    if(match_ScenarioOutlineLine(context, token)) {
1063      endRule(context, 'Step');
1064      endRule(context, 'Scenario');
1065      endRule(context, 'Scenario_Definition');
1066      startRule(context, 'Scenario_Definition');
1067      startRule(context, 'ScenarioOutline');
1068      build(context, token);
1069      return 17;
1070    }
1071    if(match_Comment(context, token)) {
1072      build(context, token);
1073      return 15;
1074    }
1075    if(match_Empty(context, token)) {
1076      build(context, token);
1077      return 15;
1078    }
1079    
1080    var stateComment = "State: 15 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0";
1081    token.detach();
1082    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1083    var error = token.isEof ?
1084      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1085      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1086    if (this.stopAtFirstError) throw error;
1087    addError(context, error);
1088    return 15;
1089  }
1090
1091
1092  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
1093  function matchTokenAt_16(token, context) {
1094    if(match_EOF(context, token)) {
1095      endRule(context, 'DataTable');
1096      endRule(context, 'Step');
1097      endRule(context, 'Scenario');
1098      endRule(context, 'Scenario_Definition');
1099      build(context, token);
1100      return 27;
1101    }
1102    if(match_TableRow(context, token)) {
1103      build(context, token);
1104      return 16;
1105    }
1106    if(match_StepLine(context, token)) {
1107      endRule(context, 'DataTable');
1108      endRule(context, 'Step');
1109      startRule(context, 'Step');
1110      build(context, token);
1111      return 15;
1112    }
1113    if(match_TagLine(context, token)) {
1114      endRule(context, 'DataTable');
1115      endRule(context, 'Step');
1116      endRule(context, 'Scenario');
1117      endRule(context, 'Scenario_Definition');
1118      startRule(context, 'Scenario_Definition');
1119      startRule(context, 'Tags');
1120      build(context, token);
1121      return 11;
1122    }
1123    if(match_ScenarioLine(context, token)) {
1124      endRule(context, 'DataTable');
1125      endRule(context, 'Step');
1126      endRule(context, 'Scenario');
1127      endRule(context, 'Scenario_Definition');
1128      startRule(context, 'Scenario_Definition');
1129      startRule(context, 'Scenario');
1130      build(context, token);
1131      return 12;
1132    }
1133    if(match_ScenarioOutlineLine(context, token)) {
1134      endRule(context, 'DataTable');
1135      endRule(context, 'Step');
1136      endRule(context, 'Scenario');
1137      endRule(context, 'Scenario_Definition');
1138      startRule(context, 'Scenario_Definition');
1139      startRule(context, 'ScenarioOutline');
1140      build(context, token);
1141      return 17;
1142    }
1143    if(match_Comment(context, token)) {
1144      build(context, token);
1145      return 16;
1146    }
1147    if(match_Empty(context, token)) {
1148      build(context, token);
1149      return 16;
1150    }
1151    
1152    var stateComment = "State: 16 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
1153    token.detach();
1154    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1155    var error = token.isEof ?
1156      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1157      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1158    if (this.stopAtFirstError) throw error;
1159    addError(context, error);
1160    return 16;
1161  }
1162
1163
1164  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:0>#ScenarioOutlineLine:0
1165  function matchTokenAt_17(token, context) {
1166    if(match_Empty(context, token)) {
1167      build(context, token);
1168      return 17;
1169    }
1170    if(match_Comment(context, token)) {
1171      build(context, token);
1172      return 19;
1173    }
1174    if(match_StepLine(context, token)) {
1175      startRule(context, 'Step');
1176      build(context, token);
1177      return 20;
1178    }
1179    if(match_TagLine(context, token)) {
1180      startRule(context, 'Examples');
1181      startRule(context, 'Tags');
1182      build(context, token);
1183      return 22;
1184    }
1185    if(match_ExamplesLine(context, token)) {
1186      startRule(context, 'Examples');
1187      build(context, token);
1188      return 23;
1189    }
1190    if(match_Other(context, token)) {
1191      startRule(context, 'Description');
1192      build(context, token);
1193      return 18;
1194    }
1195    
1196    var stateComment = "State: 17 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:0>#ScenarioOutlineLine:0";
1197    token.detach();
1198    var expectedTokens = ["#Empty", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Other"];
1199    var error = token.isEof ?
1200      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1201      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1202    if (this.stopAtFirstError) throw error;
1203    addError(context, error);
1204    return 17;
1205  }
1206
1207
1208  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>Description:0>#Other:0
1209  function matchTokenAt_18(token, context) {
1210    if(match_Comment(context, token)) {
1211      endRule(context, 'Description');
1212      build(context, token);
1213      return 19;
1214    }
1215    if(match_StepLine(context, token)) {
1216      endRule(context, 'Description');
1217      startRule(context, 'Step');
1218      build(context, token);
1219      return 20;
1220    }
1221    if(match_TagLine(context, token)) {
1222      endRule(context, 'Description');
1223      startRule(context, 'Examples');
1224      startRule(context, 'Tags');
1225      build(context, token);
1226      return 22;
1227    }
1228    if(match_ExamplesLine(context, token)) {
1229      endRule(context, 'Description');
1230      startRule(context, 'Examples');
1231      build(context, token);
1232      return 23;
1233    }
1234    if(match_Other(context, token)) {
1235      build(context, token);
1236      return 18;
1237    }
1238    
1239    var stateComment = "State: 18 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>Description:0>#Other:0";
1240    token.detach();
1241    var expectedTokens = ["#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Other"];
1242    var error = token.isEof ?
1243      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1244      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1245    if (this.stopAtFirstError) throw error;
1246    addError(context, error);
1247    return 18;
1248  }
1249
1250
1251  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:2>#Comment:0
1252  function matchTokenAt_19(token, context) {
1253    if(match_Comment(context, token)) {
1254      build(context, token);
1255      return 19;
1256    }
1257    if(match_StepLine(context, token)) {
1258      startRule(context, 'Step');
1259      build(context, token);
1260      return 20;
1261    }
1262    if(match_TagLine(context, token)) {
1263      startRule(context, 'Examples');
1264      startRule(context, 'Tags');
1265      build(context, token);
1266      return 22;
1267    }
1268    if(match_ExamplesLine(context, token)) {
1269      startRule(context, 'Examples');
1270      build(context, token);
1271      return 23;
1272    }
1273    if(match_Empty(context, token)) {
1274      build(context, token);
1275      return 19;
1276    }
1277    
1278    var stateComment = "State: 19 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:2>#Comment:0";
1279    token.detach();
1280    var expectedTokens = ["#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Empty"];
1281    var error = token.isEof ?
1282      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1283      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1284    if (this.stopAtFirstError) throw error;
1285    addError(context, error);
1286    return 19;
1287  }
1288
1289
1290  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#StepLine:0
1291  function matchTokenAt_20(token, context) {
1292    if(match_TableRow(context, token)) {
1293      startRule(context, 'DataTable');
1294      build(context, token);
1295      return 21;
1296    }
1297    if(match_DocStringSeparator(context, token)) {
1298      startRule(context, 'DocString');
1299      build(context, token);
1300      return 28;
1301    }
1302    if(match_StepLine(context, token)) {
1303      endRule(context, 'Step');
1304      startRule(context, 'Step');
1305      build(context, token);
1306      return 20;
1307    }
1308    if(match_TagLine(context, token)) {
1309      endRule(context, 'Step');
1310      startRule(context, 'Examples');
1311      startRule(context, 'Tags');
1312      build(context, token);
1313      return 22;
1314    }
1315    if(match_ExamplesLine(context, token)) {
1316      endRule(context, 'Step');
1317      startRule(context, 'Examples');
1318      build(context, token);
1319      return 23;
1320    }
1321    if(match_Comment(context, token)) {
1322      build(context, token);
1323      return 20;
1324    }
1325    if(match_Empty(context, token)) {
1326      build(context, token);
1327      return 20;
1328    }
1329    
1330    var stateComment = "State: 20 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#StepLine:0";
1331    token.detach();
1332    var expectedTokens = ["#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1333    var error = token.isEof ?
1334      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1335      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1336    if (this.stopAtFirstError) throw error;
1337    addError(context, error);
1338    return 20;
1339  }
1340
1341
1342  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
1343  function matchTokenAt_21(token, context) {
1344    if(match_TableRow(context, token)) {
1345      build(context, token);
1346      return 21;
1347    }
1348    if(match_StepLine(context, token)) {
1349      endRule(context, 'DataTable');
1350      endRule(context, 'Step');
1351      startRule(context, 'Step');
1352      build(context, token);
1353      return 20;
1354    }
1355    if(match_TagLine(context, token)) {
1356      endRule(context, 'DataTable');
1357      endRule(context, 'Step');
1358      startRule(context, 'Examples');
1359      startRule(context, 'Tags');
1360      build(context, token);
1361      return 22;
1362    }
1363    if(match_ExamplesLine(context, token)) {
1364      endRule(context, 'DataTable');
1365      endRule(context, 'Step');
1366      startRule(context, 'Examples');
1367      build(context, token);
1368      return 23;
1369    }
1370    if(match_Comment(context, token)) {
1371      build(context, token);
1372      return 21;
1373    }
1374    if(match_Empty(context, token)) {
1375      build(context, token);
1376      return 21;
1377    }
1378    
1379    var stateComment = "State: 21 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
1380    token.detach();
1381    var expectedTokens = ["#TableRow", "#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1382    var error = token.isEof ?
1383      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1384      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1385    if (this.stopAtFirstError) throw error;
1386    addError(context, error);
1387    return 21;
1388  }
1389
1390
1391  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:0>Tags:0>#TagLine:0
1392  function matchTokenAt_22(token, context) {
1393    if(match_TagLine(context, token)) {
1394      build(context, token);
1395      return 22;
1396    }
1397    if(match_ExamplesLine(context, token)) {
1398      endRule(context, 'Tags');
1399      build(context, token);
1400      return 23;
1401    }
1402    if(match_Comment(context, token)) {
1403      build(context, token);
1404      return 22;
1405    }
1406    if(match_Empty(context, token)) {
1407      build(context, token);
1408      return 22;
1409    }
1410    
1411    var stateComment = "State: 22 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:0>Tags:0>#TagLine:0";
1412    token.detach();
1413    var expectedTokens = ["#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1414    var error = token.isEof ?
1415      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1416      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1417    if (this.stopAtFirstError) throw error;
1418    addError(context, error);
1419    return 22;
1420  }
1421
1422
1423  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:1>#ExamplesLine:0
1424  function matchTokenAt_23(token, context) {
1425    if(match_Empty(context, token)) {
1426      build(context, token);
1427      return 23;
1428    }
1429    if(match_Comment(context, token)) {
1430      build(context, token);
1431      return 25;
1432    }
1433    if(match_TableRow(context, token)) {
1434      build(context, token);
1435      return 26;
1436    }
1437    if(match_Other(context, token)) {
1438      startRule(context, 'Description');
1439      build(context, token);
1440      return 24;
1441    }
1442    
1443    var stateComment = "State: 23 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:1>#ExamplesLine:0";
1444    token.detach();
1445    var expectedTokens = ["#Empty", "#Comment", "#TableRow", "#Other"];
1446    var error = token.isEof ?
1447      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1448      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1449    if (this.stopAtFirstError) throw error;
1450    addError(context, error);
1451    return 23;
1452  }
1453
1454
1455  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>Description:0>#Other:0
1456  function matchTokenAt_24(token, context) {
1457    if(match_Comment(context, token)) {
1458      endRule(context, 'Description');
1459      build(context, token);
1460      return 25;
1461    }
1462    if(match_TableRow(context, token)) {
1463      endRule(context, 'Description');
1464      build(context, token);
1465      return 26;
1466    }
1467    if(match_Other(context, token)) {
1468      build(context, token);
1469      return 24;
1470    }
1471    
1472    var stateComment = "State: 24 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>Description:0>#Other:0";
1473    token.detach();
1474    var expectedTokens = ["#Comment", "#TableRow", "#Other"];
1475    var error = token.isEof ?
1476      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1477      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1478    if (this.stopAtFirstError) throw error;
1479    addError(context, error);
1480    return 24;
1481  }
1482
1483
1484  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:2>#Comment:0
1485  function matchTokenAt_25(token, context) {
1486    if(match_Comment(context, token)) {
1487      build(context, token);
1488      return 25;
1489    }
1490    if(match_TableRow(context, token)) {
1491      build(context, token);
1492      return 26;
1493    }
1494    if(match_Empty(context, token)) {
1495      build(context, token);
1496      return 25;
1497    }
1498    
1499    var stateComment = "State: 25 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:2>#Comment:0";
1500    token.detach();
1501    var expectedTokens = ["#Comment", "#TableRow", "#Empty"];
1502    var error = token.isEof ?
1503      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1504      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1505    if (this.stopAtFirstError) throw error;
1506    addError(context, error);
1507    return 25;
1508  }
1509
1510
1511  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0
1512  function matchTokenAt_26(token, context) {
1513    if(match_EOF(context, token)) {
1514      endRule(context, 'Examples');
1515      endRule(context, 'ScenarioOutline');
1516      endRule(context, 'Scenario_Definition');
1517      build(context, token);
1518      return 27;
1519    }
1520    if(match_TableRow(context, token)) {
1521      build(context, token);
1522      return 26;
1523    }
1524    if(match_TagLine(context, token)) {
1525      if(lookahead_0(context, token)) {
1526      endRule(context, 'Examples');
1527      startRule(context, 'Examples');
1528      startRule(context, 'Tags');
1529      build(context, token);
1530      return 22;
1531      }
1532    }
1533    if(match_TagLine(context, token)) {
1534      endRule(context, 'Examples');
1535      endRule(context, 'ScenarioOutline');
1536      endRule(context, 'Scenario_Definition');
1537      startRule(context, 'Scenario_Definition');
1538      startRule(context, 'Tags');
1539      build(context, token);
1540      return 11;
1541    }
1542    if(match_ExamplesLine(context, token)) {
1543      endRule(context, 'Examples');
1544      startRule(context, 'Examples');
1545      build(context, token);
1546      return 23;
1547    }
1548    if(match_ScenarioLine(context, token)) {
1549      endRule(context, 'Examples');
1550      endRule(context, 'ScenarioOutline');
1551      endRule(context, 'Scenario_Definition');
1552      startRule(context, 'Scenario_Definition');
1553      startRule(context, 'Scenario');
1554      build(context, token);
1555      return 12;
1556    }
1557    if(match_ScenarioOutlineLine(context, token)) {
1558      endRule(context, 'Examples');
1559      endRule(context, 'ScenarioOutline');
1560      endRule(context, 'Scenario_Definition');
1561      startRule(context, 'Scenario_Definition');
1562      startRule(context, 'ScenarioOutline');
1563      build(context, token);
1564      return 17;
1565    }
1566    if(match_Comment(context, token)) {
1567      build(context, token);
1568      return 26;
1569    }
1570    if(match_Empty(context, token)) {
1571      build(context, token);
1572      return 26;
1573    }
1574    
1575    var stateComment = "State: 26 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0";
1576    token.detach();
1577    var expectedTokens = ["#EOF", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1578    var error = token.isEof ?
1579      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1580      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1581    if (this.stopAtFirstError) throw error;
1582    addError(context, error);
1583    return 26;
1584  }
1585
1586
1587  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
1588  function matchTokenAt_28(token, context) {
1589    if(match_DocStringSeparator(context, token)) {
1590      build(context, token);
1591      return 29;
1592    }
1593    if(match_Other(context, token)) {
1594      build(context, token);
1595      return 28;
1596    }
1597    
1598    var stateComment = "State: 28 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
1599    token.detach();
1600    var expectedTokens = ["#DocStringSeparator", "#Other"];
1601    var error = token.isEof ?
1602      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1603      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1604    if (this.stopAtFirstError) throw error;
1605    addError(context, error);
1606    return 28;
1607  }
1608
1609
1610  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
1611  function matchTokenAt_29(token, context) {
1612    if(match_StepLine(context, token)) {
1613      endRule(context, 'DocString');
1614      endRule(context, 'Step');
1615      startRule(context, 'Step');
1616      build(context, token);
1617      return 20;
1618    }
1619    if(match_TagLine(context, token)) {
1620      endRule(context, 'DocString');
1621      endRule(context, 'Step');
1622      startRule(context, 'Examples');
1623      startRule(context, 'Tags');
1624      build(context, token);
1625      return 22;
1626    }
1627    if(match_ExamplesLine(context, token)) {
1628      endRule(context, 'DocString');
1629      endRule(context, 'Step');
1630      startRule(context, 'Examples');
1631      build(context, token);
1632      return 23;
1633    }
1634    if(match_Comment(context, token)) {
1635      build(context, token);
1636      return 29;
1637    }
1638    if(match_Empty(context, token)) {
1639      build(context, token);
1640      return 29;
1641    }
1642    
1643    var stateComment = "State: 29 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
1644    token.detach();
1645    var expectedTokens = ["#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
1646    var error = token.isEof ?
1647      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1648      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1649    if (this.stopAtFirstError) throw error;
1650    addError(context, error);
1651    return 29;
1652  }
1653
1654
1655  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
1656  function matchTokenAt_30(token, context) {
1657    if(match_DocStringSeparator(context, token)) {
1658      build(context, token);
1659      return 31;
1660    }
1661    if(match_Other(context, token)) {
1662      build(context, token);
1663      return 30;
1664    }
1665    
1666    var stateComment = "State: 30 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
1667    token.detach();
1668    var expectedTokens = ["#DocStringSeparator", "#Other"];
1669    var error = token.isEof ?
1670      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1671      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1672    if (this.stopAtFirstError) throw error;
1673    addError(context, error);
1674    return 30;
1675  }
1676
1677
1678  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
1679  function matchTokenAt_31(token, context) {
1680    if(match_EOF(context, token)) {
1681      endRule(context, 'DocString');
1682      endRule(context, 'Step');
1683      endRule(context, 'Scenario');
1684      endRule(context, 'Scenario_Definition');
1685      build(context, token);
1686      return 27;
1687    }
1688    if(match_StepLine(context, token)) {
1689      endRule(context, 'DocString');
1690      endRule(context, 'Step');
1691      startRule(context, 'Step');
1692      build(context, token);
1693      return 15;
1694    }
1695    if(match_TagLine(context, token)) {
1696      endRule(context, 'DocString');
1697      endRule(context, 'Step');
1698      endRule(context, 'Scenario');
1699      endRule(context, 'Scenario_Definition');
1700      startRule(context, 'Scenario_Definition');
1701      startRule(context, 'Tags');
1702      build(context, token);
1703      return 11;
1704    }
1705    if(match_ScenarioLine(context, token)) {
1706      endRule(context, 'DocString');
1707      endRule(context, 'Step');
1708      endRule(context, 'Scenario');
1709      endRule(context, 'Scenario_Definition');
1710      startRule(context, 'Scenario_Definition');
1711      startRule(context, 'Scenario');
1712      build(context, token);
1713      return 12;
1714    }
1715    if(match_ScenarioOutlineLine(context, token)) {
1716      endRule(context, 'DocString');
1717      endRule(context, 'Step');
1718      endRule(context, 'Scenario');
1719      endRule(context, 'Scenario_Definition');
1720      startRule(context, 'Scenario_Definition');
1721      startRule(context, 'ScenarioOutline');
1722      build(context, token);
1723      return 17;
1724    }
1725    if(match_Comment(context, token)) {
1726      build(context, token);
1727      return 31;
1728    }
1729    if(match_Empty(context, token)) {
1730      build(context, token);
1731      return 31;
1732    }
1733    
1734    var stateComment = "State: 31 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
1735    token.detach();
1736    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1737    var error = token.isEof ?
1738      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1739      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1740    if (this.stopAtFirstError) throw error;
1741    addError(context, error);
1742    return 31;
1743  }
1744
1745
1746  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
1747  function matchTokenAt_32(token, context) {
1748    if(match_DocStringSeparator(context, token)) {
1749      build(context, token);
1750      return 33;
1751    }
1752    if(match_Other(context, token)) {
1753      build(context, token);
1754      return 32;
1755    }
1756    
1757    var stateComment = "State: 32 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
1758    token.detach();
1759    var expectedTokens = ["#DocStringSeparator", "#Other"];
1760    var error = token.isEof ?
1761      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1762      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1763    if (this.stopAtFirstError) throw error;
1764    addError(context, error);
1765    return 32;
1766  }
1767
1768
1769  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
1770  function matchTokenAt_33(token, context) {
1771    if(match_EOF(context, token)) {
1772      endRule(context, 'DocString');
1773      endRule(context, 'Step');
1774      endRule(context, 'Background');
1775      build(context, token);
1776      return 27;
1777    }
1778    if(match_StepLine(context, token)) {
1779      endRule(context, 'DocString');
1780      endRule(context, 'Step');
1781      startRule(context, 'Step');
1782      build(context, token);
1783      return 9;
1784    }
1785    if(match_TagLine(context, token)) {
1786      endRule(context, 'DocString');
1787      endRule(context, 'Step');
1788      endRule(context, 'Background');
1789      startRule(context, 'Scenario_Definition');
1790      startRule(context, 'Tags');
1791      build(context, token);
1792      return 11;
1793    }
1794    if(match_ScenarioLine(context, token)) {
1795      endRule(context, 'DocString');
1796      endRule(context, 'Step');
1797      endRule(context, 'Background');
1798      startRule(context, 'Scenario_Definition');
1799      startRule(context, 'Scenario');
1800      build(context, token);
1801      return 12;
1802    }
1803    if(match_ScenarioOutlineLine(context, token)) {
1804      endRule(context, 'DocString');
1805      endRule(context, 'Step');
1806      endRule(context, 'Background');
1807      startRule(context, 'Scenario_Definition');
1808      startRule(context, 'ScenarioOutline');
1809      build(context, token);
1810      return 17;
1811    }
1812    if(match_Comment(context, token)) {
1813      build(context, token);
1814      return 33;
1815    }
1816    if(match_Empty(context, token)) {
1817      build(context, token);
1818      return 33;
1819    }
1820    
1821    var stateComment = "State: 33 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
1822    token.detach();
1823    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
1824    var error = token.isEof ?
1825      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
1826      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
1827    if (this.stopAtFirstError) throw error;
1828    addError(context, error);
1829    return 33;
1830  }
1831
1832
1833
1834  function match_EOF(context, token) {
1835    return handleExternalError(context, false, function () {
1836      return context.tokenMatcher.match_EOF(token);
1837    });
1838  }
1839
1840
1841  function match_Empty(context, token) {
1842    if(token.isEof) return false;
1843    return handleExternalError(context, false, function () {
1844      return context.tokenMatcher.match_Empty(token);
1845    });
1846  }
1847
1848
1849  function match_Comment(context, token) {
1850    if(token.isEof) return false;
1851    return handleExternalError(context, false, function () {
1852      return context.tokenMatcher.match_Comment(token);
1853    });
1854  }
1855
1856
1857  function match_TagLine(context, token) {
1858    if(token.isEof) return false;
1859    return handleExternalError(context, false, function () {
1860      return context.tokenMatcher.match_TagLine(token);
1861    });
1862  }
1863
1864
1865  function match_FeatureLine(context, token) {
1866    if(token.isEof) return false;
1867    return handleExternalError(context, false, function () {
1868      return context.tokenMatcher.match_FeatureLine(token);
1869    });
1870  }
1871
1872
1873  function match_BackgroundLine(context, token) {
1874    if(token.isEof) return false;
1875    return handleExternalError(context, false, function () {
1876      return context.tokenMatcher.match_BackgroundLine(token);
1877    });
1878  }
1879
1880
1881  function match_ScenarioLine(context, token) {
1882    if(token.isEof) return false;
1883    return handleExternalError(context, false, function () {
1884      return context.tokenMatcher.match_ScenarioLine(token);
1885    });
1886  }
1887
1888
1889  function match_ScenarioOutlineLine(context, token) {
1890    if(token.isEof) return false;
1891    return handleExternalError(context, false, function () {
1892      return context.tokenMatcher.match_ScenarioOutlineLine(token);
1893    });
1894  }
1895
1896
1897  function match_ExamplesLine(context, token) {
1898    if(token.isEof) return false;
1899    return handleExternalError(context, false, function () {
1900      return context.tokenMatcher.match_ExamplesLine(token);
1901    });
1902  }
1903
1904
1905  function match_StepLine(context, token) {
1906    if(token.isEof) return false;
1907    return handleExternalError(context, false, function () {
1908      return context.tokenMatcher.match_StepLine(token);
1909    });
1910  }
1911
1912
1913  function match_DocStringSeparator(context, token) {
1914    if(token.isEof) return false;
1915    return handleExternalError(context, false, function () {
1916      return context.tokenMatcher.match_DocStringSeparator(token);
1917    });
1918  }
1919
1920
1921  function match_TableRow(context, token) {
1922    if(token.isEof) return false;
1923    return handleExternalError(context, false, function () {
1924      return context.tokenMatcher.match_TableRow(token);
1925    });
1926  }
1927
1928
1929  function match_Language(context, token) {
1930    if(token.isEof) return false;
1931    return handleExternalError(context, false, function () {
1932      return context.tokenMatcher.match_Language(token);
1933    });
1934  }
1935
1936
1937  function match_Other(context, token) {
1938    if(token.isEof) return false;
1939    return handleExternalError(context, false, function () {
1940      return context.tokenMatcher.match_Other(token);
1941    });
1942  }
1943
1944
1945
1946  function lookahead_0(context, currentToken) {
1947    currentToken.detach();
1948    var token;
1949    var queue = [];
1950    var match = false;
1951    do {
1952      token = readToken(context);
1953      token.detach();
1954      queue.push(token);
1955
1956      if (false  || match_ExamplesLine(context, token)) {
1957        match = true;
1958        break;
1959      }
1960    } while(false  || match_Empty(context, token) || match_Comment(context, token) || match_TagLine(context, token));
1961
1962    context.tokenQueue = context.tokenQueue.concat(queue);
1963
1964    return match;
1965  }
1966
1967
1968}
1969

Source: parser.js

// This file is generated. Do not edit! Edit gherkin-javascript.razor instead.
var Errors = require('./errors');

module.exports = function Parser() {

  var RULE_TYPES = [
    'None',
    '_EOF', // #EOF
    '_Empty', // #Empty
    '_Comment', // #Comment
    '_TagLine', // #TagLine
    '_FeatureLine', // #FeatureLine
    '_BackgroundLine', // #BackgroundLine
    '_ScenarioLine', // #ScenarioLine
    '_ScenarioOutlineLine', // #ScenarioOutlineLine
    '_ExamplesLine', // #ExamplesLine
    '_StepLine', // #StepLine
    '_DocStringSeparator', // #DocStringSeparator
    '_TableRow', // #TableRow
    '_Language', // #Language
    '_Other', // #Other
    'Feature', // Feature! := Feature_Header Background? Scenario_Definition*
    'Feature_Header', // Feature_Header! := #Language? Tags? #FeatureLine Feature_Description
    'Background', // Background! := #BackgroundLine Background_Description Scenario_Step*
    'Scenario_Definition', // Scenario_Definition! := Tags? (Scenario | ScenarioOutline)
    'Scenario', // Scenario! := #ScenarioLine Scenario_Description Scenario_Step*
    'ScenarioOutline', // ScenarioOutline! := #ScenarioOutlineLine ScenarioOutline_Description ScenarioOutline_Step* Examples+
    'Examples', // Examples! [#Empty|#Comment|#TagLine->#ExamplesLine] := Tags? #ExamplesLine Examples_Description Examples_Table
    'Examples_Table', // Examples_Table := #TableRow+
    'Scenario_Step', // Scenario_Step := Step
    'ScenarioOutline_Step', // ScenarioOutline_Step := Step
    'Step', // Step! := #StepLine Step_Arg?
    'Step_Arg', // Step_Arg := (DataTable | DocString)
    'DataTable', // DataTable! := #TableRow+
    'DocString', // DocString! := #DocStringSeparator #Other* #DocStringSeparator
    'Tags', // Tags! := #TagLine+
    'Feature_Description', // Feature_Description := Description_Helper
    'Background_Description', // Background_Description := Description_Helper
    'Scenario_Description', // Scenario_Description := Description_Helper
    'ScenarioOutline_Description', // ScenarioOutline_Description := Description_Helper
    'Examples_Description', // Examples_Description := Description_Helper
    'Description_Helper', // Description_Helper := #Empty* Description? #Comment*
    'Description', // Description! := #Other+
  ]

  var context = {};

  this.parse = function(tokenScanner, astBuilder, tokenMatcher) {
    context.tokenScanner = tokenScanner;
    context.astBuilder = astBuilder;
    context.tokenMatcher = tokenMatcher;
    context.tokenQueue = [];
    context.errors = [];

    startRule(context, 'Feature');
    var state = 0;
    var token = null;
    while(true) {
      token = readToken(context);
      state = matchToken(state, token, context);
      if(token.isEof) break;
    }

    endRule(context, 'Feature');

    // TODO: Similar optimisation in C#/Java/JavaScript
    if(context.errors.length == 1) {
      throw context.errors[0];
    } else if(context.errors.length > 1) {
      throw Errors.CompositeParserException.create(context.errors);
    }

    return getResult(context);
  };

  function addError(context, error) {
    context.errors.push(error);
    if (context.errors.length > 10)
      throw Errors.CompositeParserException.create(context.errors);
  }

  function startRule(context, ruleType) {
    handleAstError(context, function () {
      context.astBuilder.startRule(ruleType);
    });
  }

  function endRule(context, ruleType) {
    handleAstError(context, function () {
      context.astBuilder.endRule(ruleType);
    });
  }

  function build(context, token) {
    handleAstError(context, function () {
      context.astBuilder.build(token);
    });
  }

  function getResult(context) {
    return context.astBuilder.getResult();
  }

  function handleAstError(context, action) {
    handleExternalError(context, true, action)
  }

  function handleExternalError(context, defaultValue, action) {
    if(this.stopAtFirstError) return action();
    try {
      return action();
    } catch (e) {
      if(e instanceof Errors.CompositeParserException) {
        e.errors.forEach(function (error) {
          addError(context, error);
        });
      } else if(e instanceof Errors.ParserException) {
        addError(context, e);
      } else {
        throw e;
      }
    }
    return defaultValue;
  }

  function readToken(context) {
    return context.tokenQueue.length > 0 ?
      context.tokenQueue.shift() :
      context.tokenScanner.read();
  }

  function matchToken(state, token, context) {
    switch(state) {
    case 0:
      return matchTokenAt_0(token, context);
    case 1:
      return matchTokenAt_1(token, context);
    case 2:
      return matchTokenAt_2(token, context);
    case 3:
      return matchTokenAt_3(token, context);
    case 4:
      return matchTokenAt_4(token, context);
    case 5:
      return matchTokenAt_5(token, context);
    case 6:
      return matchTokenAt_6(token, context);
    case 7:
      return matchTokenAt_7(token, context);
    case 8:
      return matchTokenAt_8(token, context);
    case 9:
      return matchTokenAt_9(token, context);
    case 10:
      return matchTokenAt_10(token, context);
    case 11:
      return matchTokenAt_11(token, context);
    case 12:
      return matchTokenAt_12(token, context);
    case 13:
      return matchTokenAt_13(token, context);
    case 14:
      return matchTokenAt_14(token, context);
    case 15:
      return matchTokenAt_15(token, context);
    case 16:
      return matchTokenAt_16(token, context);
    case 17:
      return matchTokenAt_17(token, context);
    case 18:
      return matchTokenAt_18(token, context);
    case 19:
      return matchTokenAt_19(token, context);
    case 20:
      return matchTokenAt_20(token, context);
    case 21:
      return matchTokenAt_21(token, context);
    case 22:
      return matchTokenAt_22(token, context);
    case 23:
      return matchTokenAt_23(token, context);
    case 24:
      return matchTokenAt_24(token, context);
    case 25:
      return matchTokenAt_25(token, context);
    case 26:
      return matchTokenAt_26(token, context);
    case 28:
      return matchTokenAt_28(token, context);
    case 29:
      return matchTokenAt_29(token, context);
    case 30:
      return matchTokenAt_30(token, context);
    case 31:
      return matchTokenAt_31(token, context);
    case 32:
      return matchTokenAt_32(token, context);
    case 33:
      return matchTokenAt_33(token, context);
    default:
      throw new Error("Unknown state: " + state);
    }
  }


  // Start
  function matchTokenAt_0(token, context) {
    if(match_Language(context, token)) {
      startRule(context, 'Feature_Header');
      build(context, token);
      return 1;
    }
    if(match_TagLine(context, token)) {
      startRule(context, 'Feature_Header');
      startRule(context, 'Tags');
      build(context, token);
      return 2;
    }
    if(match_FeatureLine(context, token)) {
      startRule(context, 'Feature_Header');
      build(context, token);
      return 3;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 0;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 0;
    }
    
    var stateComment = "State: 0 - Start";
    token.detach();
    var expectedTokens = ["#Language", "#TagLine", "#FeatureLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 0;
  }


  // Feature:0>Feature_Header:0>#Language:0
  function matchTokenAt_1(token, context) {
    if(match_TagLine(context, token)) {
      startRule(context, 'Tags');
      build(context, token);
      return 2;
    }
    if(match_FeatureLine(context, token)) {
      build(context, token);
      return 3;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 1;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 1;
    }
    
    var stateComment = "State: 1 - Feature:0>Feature_Header:0>#Language:0";
    token.detach();
    var expectedTokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 1;
  }


  // Feature:0>Feature_Header:1>Tags:0>#TagLine:0
  function matchTokenAt_2(token, context) {
    if(match_TagLine(context, token)) {
      build(context, token);
      return 2;
    }
    if(match_FeatureLine(context, token)) {
      endRule(context, 'Tags');
      build(context, token);
      return 3;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 2;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 2;
    }
    
    var stateComment = "State: 2 - Feature:0>Feature_Header:1>Tags:0>#TagLine:0";
    token.detach();
    var expectedTokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 2;
  }


  // Feature:0>Feature_Header:2>#FeatureLine:0
  function matchTokenAt_3(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Feature_Header');
      build(context, token);
      return 27;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 3;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 5;
    }
    if(match_BackgroundLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Background');
      build(context, token);
      return 6;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Other(context, token)) {
      startRule(context, 'Description');
      build(context, token);
      return 4;
    }
    
    var stateComment = "State: 3 - Feature:0>Feature_Header:2>#FeatureLine:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 3;
  }


  // Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:1>Description:0>#Other:0
  function matchTokenAt_4(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Feature_Header');
      build(context, token);
      return 27;
    }
    if(match_Comment(context, token)) {
      endRule(context, 'Description');
      build(context, token);
      return 5;
    }
    if(match_BackgroundLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Feature_Header');
      startRule(context, 'Background');
      build(context, token);
      return 6;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 4;
    }
    
    var stateComment = "State: 4 - Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:1>Description:0>#Other:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 4;
  }


  // Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:2>#Comment:0
  function matchTokenAt_5(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Feature_Header');
      build(context, token);
      return 27;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 5;
    }
    if(match_BackgroundLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Background');
      build(context, token);
      return 6;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Feature_Header');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 5;
    }
    
    var stateComment = "State: 5 - Feature:0>Feature_Header:3>Feature_Description:0>Description_Helper:2>#Comment:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 5;
  }


  // Feature:1>Background:0>#BackgroundLine:0
  function matchTokenAt_6(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Background');
      build(context, token);
      return 27;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 6;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 8;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 9;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Other(context, token)) {
      startRule(context, 'Description');
      build(context, token);
      return 7;
    }
    
    var stateComment = "State: 6 - Feature:1>Background:0>#BackgroundLine:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 6;
  }


  // Feature:1>Background:1>Background_Description:0>Description_Helper:1>Description:0>#Other:0
  function matchTokenAt_7(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Background');
      build(context, token);
      return 27;
    }
    if(match_Comment(context, token)) {
      endRule(context, 'Description');
      build(context, token);
      return 8;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Description');
      startRule(context, 'Step');
      build(context, token);
      return 9;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 7;
    }
    
    var stateComment = "State: 7 - Feature:1>Background:1>Background_Description:0>Description_Helper:1>Description:0>#Other:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 7;
  }


  // Feature:1>Background:1>Background_Description:0>Description_Helper:2>#Comment:0
  function matchTokenAt_8(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Background');
      build(context, token);
      return 27;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 8;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 9;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 8;
    }
    
    var stateComment = "State: 8 - Feature:1>Background:1>Background_Description:0>Description_Helper:2>#Comment:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 8;
  }


  // Feature:1>Background:2>Scenario_Step:0>Step:0>#StepLine:0
  function matchTokenAt_9(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Background');
      build(context, token);
      return 27;
    }
    if(match_TableRow(context, token)) {
      startRule(context, 'DataTable');
      build(context, token);
      return 10;
    }
    if(match_DocStringSeparator(context, token)) {
      startRule(context, 'DocString');
      build(context, token);
      return 32;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 9;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 9;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 9;
    }
    
    var stateComment = "State: 9 - Feature:1>Background:2>Scenario_Step:0>Step:0>#StepLine:0";
    token.detach();
    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 9;
  }


  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
  function matchTokenAt_10(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Background');
      build(context, token);
      return 27;
    }
    if(match_TableRow(context, token)) {
      build(context, token);
      return 10;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 9;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 10;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 10;
    }
    
    var stateComment = "State: 10 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
    token.detach();
    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 10;
  }


  // Feature:2>Scenario_Definition:0>Tags:0>#TagLine:0
  function matchTokenAt_11(token, context) {
    if(match_TagLine(context, token)) {
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Tags');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Tags');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 11;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 11;
    }
    
    var stateComment = "State: 11 - Feature:2>Scenario_Definition:0>Tags:0>#TagLine:0";
    token.detach();
    var expectedTokens = ["#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 11;
  }


  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:0>#ScenarioLine:0
  function matchTokenAt_12(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 27;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 12;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 14;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 15;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Other(context, token)) {
      startRule(context, 'Description');
      build(context, token);
      return 13;
    }
    
    var stateComment = "State: 12 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:0>#ScenarioLine:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 12;
  }


  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0
  function matchTokenAt_13(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 27;
    }
    if(match_Comment(context, token)) {
      endRule(context, 'Description');
      build(context, token);
      return 14;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Description');
      startRule(context, 'Step');
      build(context, token);
      return 15;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 13;
    }
    
    var stateComment = "State: 13 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 13;
  }


  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0
  function matchTokenAt_14(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 27;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 14;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 15;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 14;
    }
    
    var stateComment = "State: 14 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 14;
  }


  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0
  function matchTokenAt_15(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 27;
    }
    if(match_TableRow(context, token)) {
      startRule(context, 'DataTable');
      build(context, token);
      return 16;
    }
    if(match_DocStringSeparator(context, token)) {
      startRule(context, 'DocString');
      build(context, token);
      return 30;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 15;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 15;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 15;
    }
    
    var stateComment = "State: 15 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0";
    token.detach();
    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 15;
  }


  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
  function matchTokenAt_16(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 27;
    }
    if(match_TableRow(context, token)) {
      build(context, token);
      return 16;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 15;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 16;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 16;
    }
    
    var stateComment = "State: 16 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
    token.detach();
    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 16;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:0>#ScenarioOutlineLine:0
  function matchTokenAt_17(token, context) {
    if(match_Empty(context, token)) {
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 19;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 20;
    }
    if(match_TagLine(context, token)) {
      startRule(context, 'Examples');
      startRule(context, 'Tags');
      build(context, token);
      return 22;
    }
    if(match_ExamplesLine(context, token)) {
      startRule(context, 'Examples');
      build(context, token);
      return 23;
    }
    if(match_Other(context, token)) {
      startRule(context, 'Description');
      build(context, token);
      return 18;
    }
    
    var stateComment = "State: 17 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:0>#ScenarioOutlineLine:0";
    token.detach();
    var expectedTokens = ["#Empty", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 17;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>Description:0>#Other:0
  function matchTokenAt_18(token, context) {
    if(match_Comment(context, token)) {
      endRule(context, 'Description');
      build(context, token);
      return 19;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Description');
      startRule(context, 'Step');
      build(context, token);
      return 20;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Description');
      startRule(context, 'Examples');
      startRule(context, 'Tags');
      build(context, token);
      return 22;
    }
    if(match_ExamplesLine(context, token)) {
      endRule(context, 'Description');
      startRule(context, 'Examples');
      build(context, token);
      return 23;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 18;
    }
    
    var stateComment = "State: 18 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>Description:0>#Other:0";
    token.detach();
    var expectedTokens = ["#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 18;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:2>#Comment:0
  function matchTokenAt_19(token, context) {
    if(match_Comment(context, token)) {
      build(context, token);
      return 19;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 20;
    }
    if(match_TagLine(context, token)) {
      startRule(context, 'Examples');
      startRule(context, 'Tags');
      build(context, token);
      return 22;
    }
    if(match_ExamplesLine(context, token)) {
      startRule(context, 'Examples');
      build(context, token);
      return 23;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 19;
    }
    
    var stateComment = "State: 19 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:2>#Comment:0";
    token.detach();
    var expectedTokens = ["#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 19;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#StepLine:0
  function matchTokenAt_20(token, context) {
    if(match_TableRow(context, token)) {
      startRule(context, 'DataTable');
      build(context, token);
      return 21;
    }
    if(match_DocStringSeparator(context, token)) {
      startRule(context, 'DocString');
      build(context, token);
      return 28;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 20;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Step');
      startRule(context, 'Examples');
      startRule(context, 'Tags');
      build(context, token);
      return 22;
    }
    if(match_ExamplesLine(context, token)) {
      endRule(context, 'Step');
      startRule(context, 'Examples');
      build(context, token);
      return 23;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 20;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 20;
    }
    
    var stateComment = "State: 20 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#StepLine:0";
    token.detach();
    var expectedTokens = ["#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 20;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0
  function matchTokenAt_21(token, context) {
    if(match_TableRow(context, token)) {
      build(context, token);
      return 21;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 20;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      startRule(context, 'Examples');
      startRule(context, 'Tags');
      build(context, token);
      return 22;
    }
    if(match_ExamplesLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      startRule(context, 'Examples');
      build(context, token);
      return 23;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 21;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 21;
    }
    
    var stateComment = "State: 21 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>DataTable:0>#TableRow:0";
    token.detach();
    var expectedTokens = ["#TableRow", "#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 21;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:0>Tags:0>#TagLine:0
  function matchTokenAt_22(token, context) {
    if(match_TagLine(context, token)) {
      build(context, token);
      return 22;
    }
    if(match_ExamplesLine(context, token)) {
      endRule(context, 'Tags');
      build(context, token);
      return 23;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 22;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 22;
    }
    
    var stateComment = "State: 22 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:0>Tags:0>#TagLine:0";
    token.detach();
    var expectedTokens = ["#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 22;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:1>#ExamplesLine:0
  function matchTokenAt_23(token, context) {
    if(match_Empty(context, token)) {
      build(context, token);
      return 23;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 25;
    }
    if(match_TableRow(context, token)) {
      build(context, token);
      return 26;
    }
    if(match_Other(context, token)) {
      startRule(context, 'Description');
      build(context, token);
      return 24;
    }
    
    var stateComment = "State: 23 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:1>#ExamplesLine:0";
    token.detach();
    var expectedTokens = ["#Empty", "#Comment", "#TableRow", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 23;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>Description:0>#Other:0
  function matchTokenAt_24(token, context) {
    if(match_Comment(context, token)) {
      endRule(context, 'Description');
      build(context, token);
      return 25;
    }
    if(match_TableRow(context, token)) {
      endRule(context, 'Description');
      build(context, token);
      return 26;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 24;
    }
    
    var stateComment = "State: 24 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>Description:0>#Other:0";
    token.detach();
    var expectedTokens = ["#Comment", "#TableRow", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 24;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:2>#Comment:0
  function matchTokenAt_25(token, context) {
    if(match_Comment(context, token)) {
      build(context, token);
      return 25;
    }
    if(match_TableRow(context, token)) {
      build(context, token);
      return 26;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 25;
    }
    
    var stateComment = "State: 25 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:2>#Comment:0";
    token.detach();
    var expectedTokens = ["#Comment", "#TableRow", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 25;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0
  function matchTokenAt_26(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Examples');
      endRule(context, 'ScenarioOutline');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 27;
    }
    if(match_TableRow(context, token)) {
      build(context, token);
      return 26;
    }
    if(match_TagLine(context, token)) {
      if(lookahead_0(context, token)) {
      endRule(context, 'Examples');
      startRule(context, 'Examples');
      startRule(context, 'Tags');
      build(context, token);
      return 22;
      }
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Examples');
      endRule(context, 'ScenarioOutline');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ExamplesLine(context, token)) {
      endRule(context, 'Examples');
      startRule(context, 'Examples');
      build(context, token);
      return 23;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Examples');
      endRule(context, 'ScenarioOutline');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'Examples');
      endRule(context, 'ScenarioOutline');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 26;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 26;
    }
    
    var stateComment = "State: 26 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0";
    token.detach();
    var expectedTokens = ["#EOF", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 26;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
  function matchTokenAt_28(token, context) {
    if(match_DocStringSeparator(context, token)) {
      build(context, token);
      return 29;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 28;
    }
    
    var stateComment = "State: 28 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
    token.detach();
    var expectedTokens = ["#DocStringSeparator", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 28;
  }


  // Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
  function matchTokenAt_29(token, context) {
    if(match_StepLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 20;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      startRule(context, 'Examples');
      startRule(context, 'Tags');
      build(context, token);
      return 22;
    }
    if(match_ExamplesLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      startRule(context, 'Examples');
      build(context, token);
      return 23;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 29;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 29;
    }
    
    var stateComment = "State: 29 - Feature:2>Scenario_Definition:1>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
    token.detach();
    var expectedTokens = ["#StepLine", "#TagLine", "#ExamplesLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 29;
  }


  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
  function matchTokenAt_30(token, context) {
    if(match_DocStringSeparator(context, token)) {
      build(context, token);
      return 31;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 30;
    }
    
    var stateComment = "State: 30 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
    token.detach();
    var expectedTokens = ["#DocStringSeparator", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 30;
  }


  // Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
  function matchTokenAt_31(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 27;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 15;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 31;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 31;
    }
    
    var stateComment = "State: 31 - Feature:2>Scenario_Definition:1>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
    token.detach();
    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 31;
  }


  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0
  function matchTokenAt_32(token, context) {
    if(match_DocStringSeparator(context, token)) {
      build(context, token);
      return 33;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 32;
    }
    
    var stateComment = "State: 32 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:0>#DocStringSeparator:0";
    token.detach();
    var expectedTokens = ["#DocStringSeparator", "#Other"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 32;
  }


  // Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0
  function matchTokenAt_33(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Background');
      build(context, token);
      return 27;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 9;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 11;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 12;
    }
    if(match_ScenarioOutlineLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Background');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'ScenarioOutline');
      build(context, token);
      return 17;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 33;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 33;
    }
    
    var stateComment = "State: 33 - Feature:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>DocString:2>#DocStringSeparator:0";
    token.detach();
    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#ScenarioOutlineLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      new Errors.UnexpectedEOFException(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (this.stopAtFirstError) throw error;
    addError(context, error);
    return 33;
  }



  function match_EOF(context, token) {
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_EOF(token);
    });
  }


  function match_Empty(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_Empty(token);
    });
  }


  function match_Comment(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_Comment(token);
    });
  }


  function match_TagLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_TagLine(token);
    });
  }


  function match_FeatureLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_FeatureLine(token);
    });
  }


  function match_BackgroundLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_BackgroundLine(token);
    });
  }


  function match_ScenarioLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_ScenarioLine(token);
    });
  }


  function match_ScenarioOutlineLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_ScenarioOutlineLine(token);
    });
  }


  function match_ExamplesLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_ExamplesLine(token);
    });
  }


  function match_StepLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_StepLine(token);
    });
  }


  function match_DocStringSeparator(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_DocStringSeparator(token);
    });
  }


  function match_TableRow(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_TableRow(token);
    });
  }


  function match_Language(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_Language(token);
    });
  }


  function match_Other(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_Other(token);
    });
  }



  function lookahead_0(context, currentToken) {
    currentToken.detach();
    var token;
    var queue = [];
    var match = false;
    do {
      token = readToken(context);
      token.detach();
      queue.push(token);

      if (false  || match_ExamplesLine(context, token)) {
        match = true;
        break;
      }
    } while(false  || match_Empty(context, token) || match_Comment(context, token) || match_TagLine(context, token));

    context.tokenQueue = context.tokenQueue.concat(queue);

    return match;
  }


}