How to use match_StepLine method in Gherkin-python

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);
    });
  }



}

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