How to use matchTokenAt_9 method in Cucumber-gherkin

1// This file is generated. Do not edit! Edit gherkin-javascript.razor instead.
2var Errors = require('./errors');
3var AstBuilder = require('./ast_builder');
4var TokenScanner = require('./token_scanner');
5var TokenMatcher = require('./token_matcher');
6
7var RULE_TYPES = [
8  'None',
9  '_EOF', // #EOF
10  '_Empty', // #Empty
11  '_Comment', // #Comment
12  '_TagLine', // #TagLine
13  '_ScenarioLine', // #ScenarioLine
14  '_ExamplesLine', // #ExamplesLine
15  '_StepLine', // #StepLine
16  '_DocStringSeparator', // #DocStringSeparator
17  '_TableRow', // #TableRow
18  '_Language', // #Language
19  '_Other', // #Other
20  'GherkinDocument', // GherkinDocument! := Scenario_Definition*
21  'Scenario_Definition', // Scenario_Definition! := Tags? Scenario
22  'Scenario', // Scenario! := #ScenarioLine Scenario_Description Scenario_Step*
23  'Scenario_Step', // Scenario_Step := Step
24  'Step', // Step! := #StepLine Step_Arg?
25  'Step_Arg', // Step_Arg := (DataTable | DocString)
26  'DataTable', // DataTable! := #TableRow+
27  'DocString', // DocString! := #DocStringSeparator #Other* #DocStringSeparator
28  'Tags', // Tags! := #TagLine+
29  'Scenario_Description', // Scenario_Description := Description_Helper
30  'Description_Helper', // Description_Helper := #Empty* Description? #Comment*
31  'Description', // Description! := #Other+
32];
33
34module.exports = function Parser(builder) {
35  builder = builder || new AstBuilder();
36  var self = this;
37  var context;
38
39  this.parse = function(tokenScanner, tokenMatcher) {
40    if(typeof tokenScanner == 'string') {
41      tokenScanner = new TokenScanner(tokenScanner);
42    }
43    tokenMatcher = tokenMatcher || new TokenMatcher();
44    builder.reset();
45    tokenMatcher.reset();
46    context = {
47      tokenScanner: tokenScanner,
48      tokenMatcher: tokenMatcher,
49      tokenQueue: [],
50      errors: []
51    };
52    startRule(context, "GherkinDocument");
53    var state = 0;
54    var token = null;
55    while(true) {
56      token = readToken(context);
57      state = matchToken(state, token, context);
58      if(token.isEof) break;
59    }
60
61    endRule(context, "GherkinDocument");
62
63    if(context.errors.length > 0) {
64      throw Errors.CompositeParserException.create(context.errors);
65    }
66
67    return getResult();
68  };
69
70  function addError(context, error) {
71    context.errors.push(error);
72    if (context.errors.length > 10)
73      throw Errors.CompositeParserException.create(context.errors);
74  }
75
76  function startRule(context, ruleType) {
77    handleAstError(context, function () {
78      builder.startRule(ruleType);
79    });
80  }
81
82  function endRule(context, ruleType) {
83    handleAstError(context, function () {
84      builder.endRule(ruleType);
85    });
86  }
87
88  function build(context, token) {
89    handleAstError(context, function () {
90      builder.build(token);
91    });
92  }
93
94  function getResult() {
95    return builder.getResult();
96  }
97
98  function handleAstError(context, action) {
99    handleExternalError(context, true, action)
100  }
101
102  function handleExternalError(context, defaultValue, action) {
103    if(self.stopAtFirstError) return action();
104    try {
105      return action();
106    } catch (e) {
107      if(e instanceof Errors.CompositeParserException) {
108        e.errors.forEach(function (error) {
109          addError(context, error);
110        });
111      } else if(
112        e instanceof Errors.ParserException ||
113        e instanceof Errors.AstBuilderException ||
114        e instanceof Errors.UnexpectedTokenException ||
115        e instanceof Errors.NoSuchLanguageException
116      ) {
117        addError(context, e);
118      } else {
119        throw e;
120      }
121    }
122    return defaultValue;
123  }
124
125  function readToken(context) {
126    return context.tokenQueue.length > 0 ?
127      context.tokenQueue.shift() :
128      context.tokenScanner.read();
129  }
130
131  function matchToken(state, token, context) {
132    switch(state) {
133    case 0:
134      return matchTokenAt_0(token, context);
135    case 1:
136      return matchTokenAt_1(token, context);
137    case 2:
138      return matchTokenAt_2(token, context);
139    case 3:
140      return matchTokenAt_3(token, context);
141    case 4:
142      return matchTokenAt_4(token, context);
143    case 5:
144      return matchTokenAt_5(token, context);
145    case 6:
146      return matchTokenAt_6(token, context);
147    case 8:
148      return matchTokenAt_8(token, context);
149    case 9:
150      return matchTokenAt_9(token, context);
151    default:
152      throw new Error("Unknown state: " + state);
153    }
154  }
155
156
157  // Start
158  function matchTokenAt_0(token, context) {
159    if(match_EOF(context, token)) {
160      build(context, token);
161      return 7;
162    }
163    if(match_TagLine(context, token)) {
164      startRule(context, 'Scenario_Definition');
165      startRule(context, 'Tags');
166      build(context, token);
167      return 1;
168    }
169    if(match_ScenarioLine(context, token)) {
170      startRule(context, 'Scenario_Definition');
171      startRule(context, 'Scenario');
172      build(context, token);
173      return 2;
174    }
175    if(match_Comment(context, token)) {
176      build(context, token);
177      return 0;
178    }
179    if(match_Empty(context, token)) {
180      build(context, token);
181      return 0;
182    }
183    
184    var stateComment = "State: 0 - Start";
185    token.detach();
186    var expectedTokens = ["#EOF", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
187    var error = token.isEof ?
188      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
189      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
190    if (self.stopAtFirstError) throw error;
191    addError(context, error);
192    return 0;
193  }
194
195
196  // GherkinDocument:0>Scenario_Definition:0>Tags:0>#TagLine:0
197  function matchTokenAt_1(token, context) {
198    if(match_TagLine(context, token)) {
199      build(context, token);
200      return 1;
201    }
202    if(match_ScenarioLine(context, token)) {
203      endRule(context, 'Tags');
204      startRule(context, 'Scenario');
205      build(context, token);
206      return 2;
207    }
208    if(match_Comment(context, token)) {
209      build(context, token);
210      return 1;
211    }
212    if(match_Empty(context, token)) {
213      build(context, token);
214      return 1;
215    }
216    
217    var stateComment = "State: 1 - GherkinDocument:0>Scenario_Definition:0>Tags:0>#TagLine:0";
218    token.detach();
219    var expectedTokens = ["#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
220    var error = token.isEof ?
221      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
222      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
223    if (self.stopAtFirstError) throw error;
224    addError(context, error);
225    return 1;
226  }
227
228
229  // GherkinDocument:0>Scenario_Definition:1>Scenario:0>#ScenarioLine:0
230  function matchTokenAt_2(token, context) {
231    if(match_EOF(context, token)) {
232      endRule(context, 'Scenario');
233      endRule(context, 'Scenario_Definition');
234      build(context, token);
235      return 7;
236    }
237    if(match_Empty(context, token)) {
238      build(context, token);
239      return 2;
240    }
241    if(match_Comment(context, token)) {
242      build(context, token);
243      return 4;
244    }
245    if(match_StepLine(context, token)) {
246      startRule(context, 'Step');
247      build(context, token);
248      return 5;
249    }
250    if(match_TagLine(context, token)) {
251      endRule(context, 'Scenario');
252      endRule(context, 'Scenario_Definition');
253      startRule(context, 'Scenario_Definition');
254      startRule(context, 'Tags');
255      build(context, token);
256      return 1;
257    }
258    if(match_ScenarioLine(context, token)) {
259      endRule(context, 'Scenario');
260      endRule(context, 'Scenario_Definition');
261      startRule(context, 'Scenario_Definition');
262      startRule(context, 'Scenario');
263      build(context, token);
264      return 2;
265    }
266    if(match_Other(context, token)) {
267      startRule(context, 'Description');
268      build(context, token);
269      return 3;
270    }
271    
272    var stateComment = "State: 2 - GherkinDocument:0>Scenario_Definition:1>Scenario:0>#ScenarioLine:0";
273    token.detach();
274    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Other"];
275    var error = token.isEof ?
276      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
277      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
278    if (self.stopAtFirstError) throw error;
279    addError(context, error);
280    return 2;
281  }
282
283
284  // GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0
285  function matchTokenAt_3(token, context) {
286    if(match_EOF(context, token)) {
287      endRule(context, 'Description');
288      endRule(context, 'Scenario');
289      endRule(context, 'Scenario_Definition');
290      build(context, token);
291      return 7;
292    }
293    if(match_Comment(context, token)) {
294      endRule(context, 'Description');
295      build(context, token);
296      return 4;
297    }
298    if(match_StepLine(context, token)) {
299      endRule(context, 'Description');
300      startRule(context, 'Step');
301      build(context, token);
302      return 5;
303    }
304    if(match_TagLine(context, token)) {
305      endRule(context, 'Description');
306      endRule(context, 'Scenario');
307      endRule(context, 'Scenario_Definition');
308      startRule(context, 'Scenario_Definition');
309      startRule(context, 'Tags');
310      build(context, token);
311      return 1;
312    }
313    if(match_ScenarioLine(context, token)) {
314      endRule(context, 'Description');
315      endRule(context, 'Scenario');
316      endRule(context, 'Scenario_Definition');
317      startRule(context, 'Scenario_Definition');
318      startRule(context, 'Scenario');
319      build(context, token);
320      return 2;
321    }
322    if(match_Other(context, token)) {
323      build(context, token);
324      return 3;
325    }
326    
327    var stateComment = "State: 3 - GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0";
328    token.detach();
329    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Other"];
330    var error = token.isEof ?
331      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
332      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
333    if (self.stopAtFirstError) throw error;
334    addError(context, error);
335    return 3;
336  }
337
338
339  // GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0
340  function matchTokenAt_4(token, context) {
341    if(match_EOF(context, token)) {
342      endRule(context, 'Scenario');
343      endRule(context, 'Scenario_Definition');
344      build(context, token);
345      return 7;
346    }
347    if(match_Comment(context, token)) {
348      build(context, token);
349      return 4;
350    }
351    if(match_StepLine(context, token)) {
352      startRule(context, 'Step');
353      build(context, token);
354      return 5;
355    }
356    if(match_TagLine(context, token)) {
357      endRule(context, 'Scenario');
358      endRule(context, 'Scenario_Definition');
359      startRule(context, 'Scenario_Definition');
360      startRule(context, 'Tags');
361      build(context, token);
362      return 1;
363    }
364    if(match_ScenarioLine(context, token)) {
365      endRule(context, 'Scenario');
366      endRule(context, 'Scenario_Definition');
367      startRule(context, 'Scenario_Definition');
368      startRule(context, 'Scenario');
369      build(context, token);
370      return 2;
371    }
372    if(match_Empty(context, token)) {
373      build(context, token);
374      return 4;
375    }
376    
377    var stateComment = "State: 4 - GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0";
378    token.detach();
379    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Empty"];
380    var error = token.isEof ?
381      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
382      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
383    if (self.stopAtFirstError) throw error;
384    addError(context, error);
385    return 4;
386  }
387
388
389  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0
390  function matchTokenAt_5(token, context) {
391    if(match_EOF(context, token)) {
392      endRule(context, 'Step');
393      endRule(context, 'Scenario');
394      endRule(context, 'Scenario_Definition');
395      build(context, token);
396      return 7;
397    }
398    if(match_TableRow(context, token)) {
399      startRule(context, 'DataTable');
400      build(context, token);
401      return 6;
402    }
403    if(match_DocStringSeparator(context, token)) {
404      startRule(context, 'DocString');
405      build(context, token);
406      return 8;
407    }
408    if(match_StepLine(context, token)) {
409      endRule(context, 'Step');
410      startRule(context, 'Step');
411      build(context, token);
412      return 5;
413    }
414    if(match_TagLine(context, token)) {
415      endRule(context, 'Step');
416      endRule(context, 'Scenario');
417      endRule(context, 'Scenario_Definition');
418      startRule(context, 'Scenario_Definition');
419      startRule(context, 'Tags');
420      build(context, token);
421      return 1;
422    }
423    if(match_ScenarioLine(context, token)) {
424      endRule(context, 'Step');
425      endRule(context, 'Scenario');
426      endRule(context, 'Scenario_Definition');
427      startRule(context, 'Scenario_Definition');
428      startRule(context, 'Scenario');
429      build(context, token);
430      return 2;
431    }
432    if(match_Comment(context, token)) {
433      build(context, token);
434      return 5;
435    }
436    if(match_Empty(context, token)) {
437      build(context, token);
438      return 5;
439    }
440    
441    var stateComment = "State: 5 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0";
442    token.detach();
443    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
444    var error = token.isEof ?
445      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
446      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
447    if (self.stopAtFirstError) throw error;
448    addError(context, error);
449    return 5;
450  }
451
452
453  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:0>DataTable:0>#TableRow:0
454  function matchTokenAt_6(token, context) {
455    if(match_EOF(context, token)) {
456      endRule(context, 'DataTable');
457      endRule(context, 'Step');
458      endRule(context, 'Scenario');
459      endRule(context, 'Scenario_Definition');
460      build(context, token);
461      return 7;
462    }
463    if(match_TableRow(context, token)) {
464      build(context, token);
465      return 6;
466    }
467    if(match_StepLine(context, token)) {
468      endRule(context, 'DataTable');
469      endRule(context, 'Step');
470      startRule(context, 'Step');
471      build(context, token);
472      return 5;
473    }
474    if(match_TagLine(context, token)) {
475      endRule(context, 'DataTable');
476      endRule(context, 'Step');
477      endRule(context, 'Scenario');
478      endRule(context, 'Scenario_Definition');
479      startRule(context, 'Scenario_Definition');
480      startRule(context, 'Tags');
481      build(context, token);
482      return 1;
483    }
484    if(match_ScenarioLine(context, token)) {
485      endRule(context, 'DataTable');
486      endRule(context, 'Step');
487      endRule(context, 'Scenario');
488      endRule(context, 'Scenario_Definition');
489      startRule(context, 'Scenario_Definition');
490      startRule(context, 'Scenario');
491      build(context, token);
492      return 2;
493    }
494    if(match_Comment(context, token)) {
495      build(context, token);
496      return 6;
497    }
498    if(match_Empty(context, token)) {
499      build(context, token);
500      return 6;
501    }
502    
503    var stateComment = "State: 6 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:0>DataTable:0>#TableRow:0";
504    token.detach();
505    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
506    var error = token.isEof ?
507      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
508      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
509    if (self.stopAtFirstError) throw error;
510    addError(context, error);
511    return 6;
512  }
513
514
515  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:0>#DocStringSeparator:0
516  function matchTokenAt_8(token, context) {
517    if(match_DocStringSeparator(context, token)) {
518      build(context, token);
519      return 9;
520    }
521    if(match_Other(context, token)) {
522      build(context, token);
523      return 8;
524    }
525    
526    var stateComment = "State: 8 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:0>#DocStringSeparator:0";
527    token.detach();
528    var expectedTokens = ["#DocStringSeparator", "#Other"];
529    var error = token.isEof ?
530      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
531      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
532    if (self.stopAtFirstError) throw error;
533    addError(context, error);
534    return 8;
535  }
536
537
538  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:2>#DocStringSeparator:0
539  function matchTokenAt_9(token, context) {
540    if(match_EOF(context, token)) {
541      endRule(context, 'DocString');
542      endRule(context, 'Step');
543      endRule(context, 'Scenario');
544      endRule(context, 'Scenario_Definition');
545      build(context, token);
546      return 7;
547    }
548    if(match_StepLine(context, token)) {
549      endRule(context, 'DocString');
550      endRule(context, 'Step');
551      startRule(context, 'Step');
552      build(context, token);
553      return 5;
554    }
555    if(match_TagLine(context, token)) {
556      endRule(context, 'DocString');
557      endRule(context, 'Step');
558      endRule(context, 'Scenario');
559      endRule(context, 'Scenario_Definition');
560      startRule(context, 'Scenario_Definition');
561      startRule(context, 'Tags');
562      build(context, token);
563      return 1;
564    }
565    if(match_ScenarioLine(context, token)) {
566      endRule(context, 'DocString');
567      endRule(context, 'Step');
568      endRule(context, 'Scenario');
569      endRule(context, 'Scenario_Definition');
570      startRule(context, 'Scenario_Definition');
571      startRule(context, 'Scenario');
572      build(context, token);
573      return 2;
574    }
575    if(match_Comment(context, token)) {
576      build(context, token);
577      return 9;
578    }
579    if(match_Empty(context, token)) {
580      build(context, token);
581      return 9;
582    }
583    
584    var stateComment = "State: 9 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:2>#DocStringSeparator:0";
585    token.detach();
586    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
587    var error = token.isEof ?
588      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
589      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
590    if (self.stopAtFirstError) throw error;
591    addError(context, error);
592    return 9;
593  }
594
595
596
597  function match_EOF(context, token) {
598    return handleExternalError(context, false, function () {
599      return context.tokenMatcher.match_EOF(token);
600    });
601  }
602
603
604  function match_Empty(context, token) {
605    if(token.isEof) return false;
606    return handleExternalError(context, false, function () {
607      return context.tokenMatcher.match_Empty(token);
608    });
609  }
610
611
612  function match_Comment(context, token) {
613    if(token.isEof) return false;
614    return handleExternalError(context, false, function () {
615      return context.tokenMatcher.match_Comment(token);
616    });
617  }
618
619
620  function match_TagLine(context, token) {
621    if(token.isEof) return false;
622    return handleExternalError(context, false, function () {
623      return context.tokenMatcher.match_TagLine(token);
624    });
625  }
626
627
628  function match_ScenarioLine(context, token) {
629    if(token.isEof) return false;
630    return handleExternalError(context, false, function () {
631      return context.tokenMatcher.match_ScenarioLine(token);
632    });
633  }
634
635
636  function match_ExamplesLine(context, token) {
637    if(token.isEof) return false;
638    return handleExternalError(context, false, function () {
639      return context.tokenMatcher.match_ExamplesLine(token);
640    });
641  }
642
643
644  function match_StepLine(context, token) {
645    if(token.isEof) return false;
646    return handleExternalError(context, false, function () {
647      return context.tokenMatcher.match_StepLine(token);
648    });
649  }
650
651
652  function match_DocStringSeparator(context, token) {
653    if(token.isEof) return false;
654    return handleExternalError(context, false, function () {
655      return context.tokenMatcher.match_DocStringSeparator(token);
656    });
657  }
658
659
660  function match_TableRow(context, token) {
661    if(token.isEof) return false;
662    return handleExternalError(context, false, function () {
663      return context.tokenMatcher.match_TableRow(token);
664    });
665  }
666
667
668  function match_Language(context, token) {
669    if(token.isEof) return false;
670    return handleExternalError(context, false, function () {
671      return context.tokenMatcher.match_Language(token);
672    });
673  }
674
675
676  function match_Other(context, token) {
677    if(token.isEof) return false;
678    return handleExternalError(context, false, function () {
679      return context.tokenMatcher.match_Other(token);
680    });
681  }
682
683
684
685}
686

Source: parser.js

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

var RULE_TYPES = [
  'None',
  '_EOF', // #EOF
  '_Empty', // #Empty
  '_Comment', // #Comment
  '_TagLine', // #TagLine
  '_ScenarioLine', // #ScenarioLine
  '_ExamplesLine', // #ExamplesLine
  '_StepLine', // #StepLine
  '_DocStringSeparator', // #DocStringSeparator
  '_TableRow', // #TableRow
  '_Language', // #Language
  '_Other', // #Other
  'GherkinDocument', // GherkinDocument! := Scenario_Definition*
  'Scenario_Definition', // Scenario_Definition! := Tags? Scenario
  'Scenario', // Scenario! := #ScenarioLine Scenario_Description Scenario_Step*
  'Scenario_Step', // Scenario_Step := Step
  'Step', // Step! := #StepLine Step_Arg?
  'Step_Arg', // Step_Arg := (DataTable | DocString)
  'DataTable', // DataTable! := #TableRow+
  'DocString', // DocString! := #DocStringSeparator #Other* #DocStringSeparator
  'Tags', // Tags! := #TagLine+
  'Scenario_Description', // Scenario_Description := Description_Helper
  'Description_Helper', // Description_Helper := #Empty* Description? #Comment*
  'Description', // Description! := #Other+
];

module.exports = function Parser(builder) {
  builder = builder || new AstBuilder();
  var self = this;
  var context;

  this.parse = function(tokenScanner, tokenMatcher) {
    if(typeof tokenScanner == 'string') {
      tokenScanner = new TokenScanner(tokenScanner);
    }
    tokenMatcher = tokenMatcher || new TokenMatcher();
    builder.reset();
    tokenMatcher.reset();
    context = {
      tokenScanner: tokenScanner,
      tokenMatcher: tokenMatcher,
      tokenQueue: [],
      errors: []
    };
    startRule(context, "GherkinDocument");
    var state = 0;
    var token = null;
    while(true) {
      token = readToken(context);
      state = matchToken(state, token, context);
      if(token.isEof) break;
    }

    endRule(context, "GherkinDocument");

    if(context.errors.length > 0) {
      throw Errors.CompositeParserException.create(context.errors);
    }

    return getResult();
  };

  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 () {
      builder.startRule(ruleType);
    });
  }

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

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

  function getResult() {
    return builder.getResult();
  }

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

  function handleExternalError(context, defaultValue, action) {
    if(self.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 ||
        e instanceof Errors.AstBuilderException ||
        e instanceof Errors.UnexpectedTokenException ||
        e instanceof Errors.NoSuchLanguageException
      ) {
        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 8:
      return matchTokenAt_8(token, context);
    case 9:
      return matchTokenAt_9(token, context);
    default:
      throw new Error("Unknown state: " + state);
    }
  }


  // Start
  function matchTokenAt_0(token, context) {
    if(match_EOF(context, token)) {
      build(context, token);
      return 7;
    }
    if(match_TagLine(context, token)) {
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 1;
    }
    if(match_ScenarioLine(context, token)) {
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 2;
    }
    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 = ["#EOF", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 0;
  }


  // GherkinDocument:0>Scenario_Definition:0>Tags:0>#TagLine:0
  function matchTokenAt_1(token, context) {
    if(match_TagLine(context, token)) {
      build(context, token);
      return 1;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Tags');
      startRule(context, 'Scenario');
      build(context, token);
      return 2;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 1;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 1;
    }
    
    var stateComment = "State: 1 - GherkinDocument:0>Scenario_Definition:0>Tags:0>#TagLine:0";
    token.detach();
    var expectedTokens = ["#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 1;
  }


  // GherkinDocument:0>Scenario_Definition:1>Scenario:0>#ScenarioLine:0
  function matchTokenAt_2(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 7;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 2;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 4;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 5;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 1;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 2;
    }
    if(match_Other(context, token)) {
      startRule(context, 'Description');
      build(context, token);
      return 3;
    }
    
    var stateComment = "State: 2 - GherkinDocument:0>Scenario_Definition:1>Scenario:0>#ScenarioLine:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Other"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 2;
  }


  // GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0
  function matchTokenAt_3(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Description');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 7;
    }
    if(match_Comment(context, token)) {
      endRule(context, 'Description');
      build(context, token);
      return 4;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Description');
      startRule(context, 'Step');
      build(context, token);
      return 5;
    }
    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 1;
    }
    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 2;
    }
    if(match_Other(context, token)) {
      build(context, token);
      return 3;
    }
    
    var stateComment = "State: 3 - GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:1>Description:0>#Other:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Other"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 3;
  }


  // GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0
  function matchTokenAt_4(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 7;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 4;
    }
    if(match_StepLine(context, token)) {
      startRule(context, 'Step');
      build(context, token);
      return 5;
    }
    if(match_TagLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Tags');
      build(context, token);
      return 1;
    }
    if(match_ScenarioLine(context, token)) {
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario_Definition');
      startRule(context, 'Scenario');
      build(context, token);
      return 2;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 4;
    }
    
    var stateComment = "State: 4 - GherkinDocument:0>Scenario_Definition:1>Scenario:1>Scenario_Description:0>Description_Helper:2>#Comment:0";
    token.detach();
    var expectedTokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#Empty"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 4;
  }


  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0
  function matchTokenAt_5(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 7;
    }
    if(match_TableRow(context, token)) {
      startRule(context, 'DataTable');
      build(context, token);
      return 6;
    }
    if(match_DocStringSeparator(context, token)) {
      startRule(context, 'DocString');
      build(context, token);
      return 8;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 5;
    }
    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 1;
    }
    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 2;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 5;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 5;
    }
    
    var stateComment = "State: 5 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:0>#StepLine:0";
    token.detach();
    var expectedTokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 5;
  }


  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:0>DataTable:0>#TableRow:0
  function matchTokenAt_6(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 7;
    }
    if(match_TableRow(context, token)) {
      build(context, token);
      return 6;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'DataTable');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 5;
    }
    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 1;
    }
    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 2;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 6;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 6;
    }
    
    var stateComment = "State: 6 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:0>DataTable:0>#TableRow:0";
    token.detach();
    var expectedTokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 6;
  }


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


  // GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:2>#DocStringSeparator:0
  function matchTokenAt_9(token, context) {
    if(match_EOF(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      endRule(context, 'Scenario');
      endRule(context, 'Scenario_Definition');
      build(context, token);
      return 7;
    }
    if(match_StepLine(context, token)) {
      endRule(context, 'DocString');
      endRule(context, 'Step');
      startRule(context, 'Step');
      build(context, token);
      return 5;
    }
    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 1;
    }
    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 2;
    }
    if(match_Comment(context, token)) {
      build(context, token);
      return 9;
    }
    if(match_Empty(context, token)) {
      build(context, token);
      return 9;
    }
    
    var stateComment = "State: 9 - GherkinDocument:0>Scenario_Definition:1>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt0:1>DocString:2>#DocStringSeparator:0";
    token.detach();
    var expectedTokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#Comment", "#Empty"];
    var error = token.isEof ?
      Errors.UnexpectedEOFException.create(token, expectedTokens, stateComment) :
      Errors.UnexpectedTokenException.create(token, expectedTokens, stateComment);
    if (self.stopAtFirstError) throw error;
    addError(context, error);
    return 9;
  }



  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_ScenarioLine(context, token) {
    if(token.isEof) return false;
    return handleExternalError(context, false, function () {
      return context.tokenMatcher.match_ScenarioLine(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);
    });
  }



}