How to use match_token_at_36 method in Gherkin-python

Best Python code snippet using gherkin-python

Run Gherkin-python automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

parser.py

Source: parser.py Github

copy
1# This file is generated. Do not edit! Edit gherkin-python.razor instead.
2import sys
3from collections import deque
4from .ast_builder import AstBuilder
5from .token_matcher import TokenMatcher
6from .token_scanner import TokenScanner
7from .errors import UnexpectedEOFException, UnexpectedTokenException, ParserException, CompositeParserException
8
9RULE_TYPE = [
10    'None',
11    '_EOF',  # #EOF
12    '_Empty',  # #Empty
13    '_Comment',  # #Comment
14    '_TagLine',  # #TagLine
15    '_FeatureLine',  # #FeatureLine
16    '_RuleLine',  # #RuleLine
17    '_BackgroundLine',  # #BackgroundLine
18    '_ScenarioLine',  # #ScenarioLine
19    '_ExamplesLine',  # #ExamplesLine
20    '_StepLine',  # #StepLine
21    '_DocStringSeparator',  # #DocStringSeparator
22    '_TableRow',  # #TableRow
23    '_Language',  # #Language
24    '_Other',  # #Other
25    'GherkinDocument',  # GherkinDocument! := Feature?
26    'Feature',  # Feature! := FeatureHeader Background? ScenarioDefinition* Rule*
27    'FeatureHeader',  # FeatureHeader! := #Language? Tags? #FeatureLine DescriptionHelper
28    'Rule',  # Rule! := RuleHeader Background? ScenarioDefinition*
29    'RuleHeader',  # RuleHeader! := #RuleLine DescriptionHelper
30    'Background',  # Background! := #BackgroundLine DescriptionHelper Step*
31    'ScenarioDefinition',  # ScenarioDefinition! := Tags? Scenario
32    'Scenario',  # Scenario! := #ScenarioLine DescriptionHelper Step* ExamplesDefinition*
33    'ExamplesDefinition',  # ExamplesDefinition! [#Empty|#Comment|#TagLine->#ExamplesLine] := Tags? Examples
34    'Examples',  # Examples! := #ExamplesLine DescriptionHelper ExamplesTable?
35    'ExamplesTable',  # ExamplesTable! := #TableRow #TableRow*
36    'Step',  # Step! := #StepLine StepArg?
37    'StepArg',  # StepArg := (DataTable | DocString)
38    'DataTable',  # DataTable! := #TableRow+
39    'DocString',  # DocString! := #DocStringSeparator #Other* #DocStringSeparator
40    'Tags',  # Tags! := #TagLine+
41    'DescriptionHelper',  # DescriptionHelper := #Empty* Description? #Comment*
42    'Description',  # Description! := #Other+
43]
44
45
46class ParserContext(object):
47    def __init__(self, token_scanner, token_matcher, token_queue, errors):
48        self.token_scanner = token_scanner
49        self.token_matcher = token_matcher
50        self.token_queue = token_queue
51        self.errors = errors
52
53
54class Parser(object):
55    def __init__(self, ast_builder=None):
56        self.ast_builder = ast_builder if ast_builder is not None else AstBuilder()
57        self.stop_at_first_error = False
58
59    def parse(self, token_scanner_or_str, token_matcher=None):
60        if sys.version_info < (3, 0):
61            token_scanner = TokenScanner(token_scanner_or_str) if isinstance(token_scanner_or_str, basestring) else token_scanner_or_str
62        else:
63            token_scanner = TokenScanner(token_scanner_or_str) if isinstance(token_scanner_or_str, str) else token_scanner_or_str
64        self.ast_builder.reset()
65        if token_matcher is None:
66            token_matcher = TokenMatcher()
67        token_matcher.reset()
68        context = ParserContext(
69            token_scanner,
70            token_matcher,
71            deque(),
72            [])
73
74        self.start_rule(context, 'GherkinDocument')
75        state = 0
76        token = None
77        while True:
78            token = self.read_token(context)
79            state = self.match_token(state, token, context)
80            if token.eof():
81                break
82
83        self.end_rule(context, 'GherkinDocument')
84
85        if context.errors:
86            raise CompositeParserException(context.errors)
87
88        return self.get_result()
89
90    def build(self, context, token):
91        self.handle_ast_error(context, token, self.ast_builder.build)
92
93    def add_error(self, context, error):
94        context.errors.append(error)
95        if len(context.errors) > 10:
96            raise CompositeParserException(context.errors)
97
98    def start_rule(self, context, rule_type):
99        self.handle_ast_error(context, rule_type, self.ast_builder.start_rule)
100
101    def end_rule(self, context, rule_type):
102        self.handle_ast_error(context, rule_type, self.ast_builder.end_rule)
103
104    def get_result(self):
105        return self.ast_builder.get_result()
106
107    def read_token(self, context):
108        if context.token_queue:
109            return context.token_queue.popleft()
110        else:
111            return context.token_scanner.read()
112
113    def match_EOF(self, context, token):
114        return self.handle_external_error(context, False, token, context.token_matcher.match_EOF)
115
116    def match_Empty(self, context, token):
117        if token.eof():
118            return False
119        return self.handle_external_error(context, False, token, context.token_matcher.match_Empty)
120
121    def match_Comment(self, context, token):
122        if token.eof():
123            return False
124        return self.handle_external_error(context, False, token, context.token_matcher.match_Comment)
125
126    def match_TagLine(self, context, token):
127        if token.eof():
128            return False
129        return self.handle_external_error(context, False, token, context.token_matcher.match_TagLine)
130
131    def match_FeatureLine(self, context, token):
132        if token.eof():
133            return False
134        return self.handle_external_error(context, False, token, context.token_matcher.match_FeatureLine)
135
136    def match_RuleLine(self, context, token):
137        if token.eof():
138            return False
139        return self.handle_external_error(context, False, token, context.token_matcher.match_RuleLine)
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_ExamplesLine(self, context, token):
152        if token.eof():
153            return False
154        return self.handle_external_error(context, False, token, context.token_matcher.match_ExamplesLine)
155
156    def match_StepLine(self, context, token):
157        if token.eof():
158            return False
159        return self.handle_external_error(context, False, token, context.token_matcher.match_StepLine)
160
161    def match_DocStringSeparator(self, context, token):
162        if token.eof():
163            return False
164        return self.handle_external_error(context, False, token, context.token_matcher.match_DocStringSeparator)
165
166    def match_TableRow(self, context, token):
167        if token.eof():
168            return False
169        return self.handle_external_error(context, False, token, context.token_matcher.match_TableRow)
170
171    def match_Language(self, context, token):
172        if token.eof():
173            return False
174        return self.handle_external_error(context, False, token, context.token_matcher.match_Language)
175
176    def match_Other(self, context, token):
177        if token.eof():
178            return False
179        return self.handle_external_error(context, False, token, context.token_matcher.match_Other)
180
181    def match_token(self, state, token, context):
182        state_map = {
183            0: self.match_token_at_0,
184            1: self.match_token_at_1,
185            2: self.match_token_at_2,
186            3: self.match_token_at_3,
187            4: self.match_token_at_4,
188            5: self.match_token_at_5,
189            6: self.match_token_at_6,
190            7: self.match_token_at_7,
191            8: self.match_token_at_8,
192            9: self.match_token_at_9,
193            10: self.match_token_at_10,
194            11: self.match_token_at_11,
195            12: self.match_token_at_12,
196            13: self.match_token_at_13,
197            14: self.match_token_at_14,
198            15: self.match_token_at_15,
199            16: self.match_token_at_16,
200            17: self.match_token_at_17,
201            18: self.match_token_at_18,
202            19: self.match_token_at_19,
203            20: self.match_token_at_20,
204            21: self.match_token_at_21,
205            22: self.match_token_at_22,
206            23: self.match_token_at_23,
207            24: self.match_token_at_24,
208            25: self.match_token_at_25,
209            26: self.match_token_at_26,
210            27: self.match_token_at_27,
211            28: self.match_token_at_28,
212            29: self.match_token_at_29,
213            30: self.match_token_at_30,
214            31: self.match_token_at_31,
215            32: self.match_token_at_32,
216            33: self.match_token_at_33,
217            34: self.match_token_at_34,
218            35: self.match_token_at_35,
219            36: self.match_token_at_36,
220            37: self.match_token_at_37,
221            38: self.match_token_at_38,
222            39: self.match_token_at_39,
223            40: self.match_token_at_40,
224            42: self.match_token_at_42,
225            43: self.match_token_at_43,
226            44: self.match_token_at_44,
227            45: self.match_token_at_45,
228            46: self.match_token_at_46,
229            47: self.match_token_at_47,
230            48: self.match_token_at_48,
231            49: self.match_token_at_49,
232        }
233        if state in state_map:
234            return state_map[state](token, context)
235        else:
236            raise RuntimeError("Unknown state: " + str(state))
237
238    # Start
239    def match_token_at_0(self, token, context):
240        if self.match_EOF(context, token):
241                self.build(context, token)
242                return 41
243        if self.match_Language(context, token):
244                self.start_rule(context, 'Feature')
245                self.start_rule(context, 'FeatureHeader')
246                self.build(context, token)
247                return 1
248        if self.match_TagLine(context, token):
249                self.start_rule(context, 'Feature')
250                self.start_rule(context, 'FeatureHeader')
251                self.start_rule(context, 'Tags')
252                self.build(context, token)
253                return 2
254        if self.match_FeatureLine(context, token):
255                self.start_rule(context, 'Feature')
256                self.start_rule(context, 'FeatureHeader')
257                self.build(context, token)
258                return 3
259        if self.match_Comment(context, token):
260                self.build(context, token)
261                return 0
262        if self.match_Empty(context, token):
263                self.build(context, token)
264                return 0
265
266        state_comment = "State: 0 - Start"
267        token.detach
268        expected_tokens = ["#EOF", "#Language", "#TagLine", "#FeatureLine", "#Comment", "#Empty"]
269        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
270        if (self.stop_at_first_error):
271            raise error
272        self.add_error(context, error)
273        return 0
274
275    # GherkinDocument:0>Feature:0>FeatureHeader:0>#Language:0
276    def match_token_at_1(self, token, context):
277        if self.match_TagLine(context, token):
278                self.start_rule(context, 'Tags')
279                self.build(context, token)
280                return 2
281        if self.match_FeatureLine(context, token):
282                self.build(context, token)
283                return 3
284        if self.match_Comment(context, token):
285                self.build(context, token)
286                return 1
287        if self.match_Empty(context, token):
288                self.build(context, token)
289                return 1
290
291        state_comment = "State: 1 - GherkinDocument:0>Feature:0>FeatureHeader:0>#Language:0"
292        token.detach
293        expected_tokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"]
294        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
295        if (self.stop_at_first_error):
296            raise error
297        self.add_error(context, error)
298        return 1
299
300    # GherkinDocument:0>Feature:0>FeatureHeader:1>Tags:0>#TagLine:0
301    def match_token_at_2(self, token, context):
302        if self.match_TagLine(context, token):
303                self.build(context, token)
304                return 2
305        if self.match_FeatureLine(context, token):
306                self.end_rule(context, 'Tags')
307                self.build(context, token)
308                return 3
309        if self.match_Comment(context, token):
310                self.build(context, token)
311                return 2
312        if self.match_Empty(context, token):
313                self.build(context, token)
314                return 2
315
316        state_comment = "State: 2 - GherkinDocument:0>Feature:0>FeatureHeader:1>Tags:0>#TagLine:0"
317        token.detach
318        expected_tokens = ["#TagLine", "#FeatureLine", "#Comment", "#Empty"]
319        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
320        if (self.stop_at_first_error):
321            raise error
322        self.add_error(context, error)
323        return 2
324
325    # GherkinDocument:0>Feature:0>FeatureHeader:2>#FeatureLine:0
326    def match_token_at_3(self, token, context):
327        if self.match_EOF(context, token):
328                self.end_rule(context, 'FeatureHeader')
329                self.end_rule(context, 'Feature')
330                self.build(context, token)
331                return 41
332        if self.match_Empty(context, token):
333                self.build(context, token)
334                return 3
335        if self.match_Comment(context, token):
336                self.build(context, token)
337                return 5
338        if self.match_BackgroundLine(context, token):
339                self.end_rule(context, 'FeatureHeader')
340                self.start_rule(context, 'Background')
341                self.build(context, token)
342                return 6
343        if self.match_TagLine(context, token):
344                self.end_rule(context, 'FeatureHeader')
345                self.start_rule(context, 'ScenarioDefinition')
346                self.start_rule(context, 'Tags')
347                self.build(context, token)
348                return 11
349        if self.match_ScenarioLine(context, token):
350                self.end_rule(context, 'FeatureHeader')
351                self.start_rule(context, 'ScenarioDefinition')
352                self.start_rule(context, 'Scenario')
353                self.build(context, token)
354                return 12
355        if self.match_RuleLine(context, token):
356                self.end_rule(context, 'FeatureHeader')
357                self.start_rule(context, 'Rule')
358                self.start_rule(context, 'RuleHeader')
359                self.build(context, token)
360                return 22
361        if self.match_Other(context, token):
362                self.start_rule(context, 'Description')
363                self.build(context, token)
364                return 4
365
366        state_comment = "State: 3 - GherkinDocument:0>Feature:0>FeatureHeader:2>#FeatureLine:0"
367        token.detach
368        expected_tokens = ["#EOF", "#Empty", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
369        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
370        if (self.stop_at_first_error):
371            raise error
372        self.add_error(context, error)
373        return 3
374
375    # GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:1>Description:0>#Other:0
376    def match_token_at_4(self, token, context):
377        if self.match_EOF(context, token):
378                self.end_rule(context, 'Description')
379                self.end_rule(context, 'FeatureHeader')
380                self.end_rule(context, 'Feature')
381                self.build(context, token)
382                return 41
383        if self.match_Comment(context, token):
384                self.end_rule(context, 'Description')
385                self.build(context, token)
386                return 5
387        if self.match_BackgroundLine(context, token):
388                self.end_rule(context, 'Description')
389                self.end_rule(context, 'FeatureHeader')
390                self.start_rule(context, 'Background')
391                self.build(context, token)
392                return 6
393        if self.match_TagLine(context, token):
394                self.end_rule(context, 'Description')
395                self.end_rule(context, 'FeatureHeader')
396                self.start_rule(context, 'ScenarioDefinition')
397                self.start_rule(context, 'Tags')
398                self.build(context, token)
399                return 11
400        if self.match_ScenarioLine(context, token):
401                self.end_rule(context, 'Description')
402                self.end_rule(context, 'FeatureHeader')
403                self.start_rule(context, 'ScenarioDefinition')
404                self.start_rule(context, 'Scenario')
405                self.build(context, token)
406                return 12
407        if self.match_RuleLine(context, token):
408                self.end_rule(context, 'Description')
409                self.end_rule(context, 'FeatureHeader')
410                self.start_rule(context, 'Rule')
411                self.start_rule(context, 'RuleHeader')
412                self.build(context, token)
413                return 22
414        if self.match_Other(context, token):
415                self.build(context, token)
416                return 4
417
418        state_comment = "State: 4 - GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:1>Description:0>#Other:0"
419        token.detach
420        expected_tokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
421        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
422        if (self.stop_at_first_error):
423            raise error
424        self.add_error(context, error)
425        return 4
426
427    # GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:2>#Comment:0
428    def match_token_at_5(self, token, context):
429        if self.match_EOF(context, token):
430                self.end_rule(context, 'FeatureHeader')
431                self.end_rule(context, 'Feature')
432                self.build(context, token)
433                return 41
434        if self.match_Comment(context, token):
435                self.build(context, token)
436                return 5
437        if self.match_BackgroundLine(context, token):
438                self.end_rule(context, 'FeatureHeader')
439                self.start_rule(context, 'Background')
440                self.build(context, token)
441                return 6
442        if self.match_TagLine(context, token):
443                self.end_rule(context, 'FeatureHeader')
444                self.start_rule(context, 'ScenarioDefinition')
445                self.start_rule(context, 'Tags')
446                self.build(context, token)
447                return 11
448        if self.match_ScenarioLine(context, token):
449                self.end_rule(context, 'FeatureHeader')
450                self.start_rule(context, 'ScenarioDefinition')
451                self.start_rule(context, 'Scenario')
452                self.build(context, token)
453                return 12
454        if self.match_RuleLine(context, token):
455                self.end_rule(context, 'FeatureHeader')
456                self.start_rule(context, 'Rule')
457                self.start_rule(context, 'RuleHeader')
458                self.build(context, token)
459                return 22
460        if self.match_Empty(context, token):
461                self.build(context, token)
462                return 5
463
464        state_comment = "State: 5 - GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:2>#Comment:0"
465        token.detach
466        expected_tokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"]
467        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
468        if (self.stop_at_first_error):
469            raise error
470        self.add_error(context, error)
471        return 5
472
473    # GherkinDocument:0>Feature:1>Background:0>#BackgroundLine:0
474    def match_token_at_6(self, token, context):
475        if self.match_EOF(context, token):
476                self.end_rule(context, 'Background')
477                self.end_rule(context, 'Feature')
478                self.build(context, token)
479                return 41
480        if self.match_Empty(context, token):
481                self.build(context, token)
482                return 6
483        if self.match_Comment(context, token):
484                self.build(context, token)
485                return 8
486        if self.match_StepLine(context, token):
487                self.start_rule(context, 'Step')
488                self.build(context, token)
489                return 9
490        if self.match_TagLine(context, token):
491                self.end_rule(context, 'Background')
492                self.start_rule(context, 'ScenarioDefinition')
493                self.start_rule(context, 'Tags')
494                self.build(context, token)
495                return 11
496        if self.match_ScenarioLine(context, token):
497                self.end_rule(context, 'Background')
498                self.start_rule(context, 'ScenarioDefinition')
499                self.start_rule(context, 'Scenario')
500                self.build(context, token)
501                return 12
502        if self.match_RuleLine(context, token):
503                self.end_rule(context, 'Background')
504                self.start_rule(context, 'Rule')
505                self.start_rule(context, 'RuleHeader')
506                self.build(context, token)
507                return 22
508        if self.match_Other(context, token):
509                self.start_rule(context, 'Description')
510                self.build(context, token)
511                return 7
512
513        state_comment = "State: 6 - GherkinDocument:0>Feature:1>Background:0>#BackgroundLine:0"
514        token.detach
515        expected_tokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
516        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
517        if (self.stop_at_first_error):
518            raise error
519        self.add_error(context, error)
520        return 6
521
522    # GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:1>Description:0>#Other:0
523    def match_token_at_7(self, token, context):
524        if self.match_EOF(context, token):
525                self.end_rule(context, 'Description')
526                self.end_rule(context, 'Background')
527                self.end_rule(context, 'Feature')
528                self.build(context, token)
529                return 41
530        if self.match_Comment(context, token):
531                self.end_rule(context, 'Description')
532                self.build(context, token)
533                return 8
534        if self.match_StepLine(context, token):
535                self.end_rule(context, 'Description')
536                self.start_rule(context, 'Step')
537                self.build(context, token)
538                return 9
539        if self.match_TagLine(context, token):
540                self.end_rule(context, 'Description')
541                self.end_rule(context, 'Background')
542                self.start_rule(context, 'ScenarioDefinition')
543                self.start_rule(context, 'Tags')
544                self.build(context, token)
545                return 11
546        if self.match_ScenarioLine(context, token):
547                self.end_rule(context, 'Description')
548                self.end_rule(context, 'Background')
549                self.start_rule(context, 'ScenarioDefinition')
550                self.start_rule(context, 'Scenario')
551                self.build(context, token)
552                return 12
553        if self.match_RuleLine(context, token):
554                self.end_rule(context, 'Description')
555                self.end_rule(context, 'Background')
556                self.start_rule(context, 'Rule')
557                self.start_rule(context, 'RuleHeader')
558                self.build(context, token)
559                return 22
560        if self.match_Other(context, token):
561                self.build(context, token)
562                return 7
563
564        state_comment = "State: 7 - GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:1>Description:0>#Other:0"
565        token.detach
566        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
567        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
568        if (self.stop_at_first_error):
569            raise error
570        self.add_error(context, error)
571        return 7
572
573    # GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:2>#Comment:0
574    def match_token_at_8(self, token, context):
575        if self.match_EOF(context, token):
576                self.end_rule(context, 'Background')
577                self.end_rule(context, 'Feature')
578                self.build(context, token)
579                return 41
580        if self.match_Comment(context, token):
581                self.build(context, token)
582                return 8
583        if self.match_StepLine(context, token):
584                self.start_rule(context, 'Step')
585                self.build(context, token)
586                return 9
587        if self.match_TagLine(context, token):
588                self.end_rule(context, 'Background')
589                self.start_rule(context, 'ScenarioDefinition')
590                self.start_rule(context, 'Tags')
591                self.build(context, token)
592                return 11
593        if self.match_ScenarioLine(context, token):
594                self.end_rule(context, 'Background')
595                self.start_rule(context, 'ScenarioDefinition')
596                self.start_rule(context, 'Scenario')
597                self.build(context, token)
598                return 12
599        if self.match_RuleLine(context, token):
600                self.end_rule(context, 'Background')
601                self.start_rule(context, 'Rule')
602                self.start_rule(context, 'RuleHeader')
603                self.build(context, token)
604                return 22
605        if self.match_Empty(context, token):
606                self.build(context, token)
607                return 8
608
609        state_comment = "State: 8 - GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:2>#Comment:0"
610        token.detach
611        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"]
612        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
613        if (self.stop_at_first_error):
614            raise error
615        self.add_error(context, error)
616        return 8
617
618    # GherkinDocument:0>Feature:1>Background:2>Step:0>#StepLine:0
619    def match_token_at_9(self, token, context):
620        if self.match_EOF(context, token):
621                self.end_rule(context, 'Step')
622                self.end_rule(context, 'Background')
623                self.end_rule(context, 'Feature')
624                self.build(context, token)
625                return 41
626        if self.match_TableRow(context, token):
627                self.start_rule(context, 'DataTable')
628                self.build(context, token)
629                return 10
630        if self.match_DocStringSeparator(context, token):
631                self.start_rule(context, 'DocString')
632                self.build(context, token)
633                return 48
634        if self.match_StepLine(context, token):
635                self.end_rule(context, 'Step')
636                self.start_rule(context, 'Step')
637                self.build(context, token)
638                return 9
639        if self.match_TagLine(context, token):
640                self.end_rule(context, 'Step')
641                self.end_rule(context, 'Background')
642                self.start_rule(context, 'ScenarioDefinition')
643                self.start_rule(context, 'Tags')
644                self.build(context, token)
645                return 11
646        if self.match_ScenarioLine(context, token):
647                self.end_rule(context, 'Step')
648                self.end_rule(context, 'Background')
649                self.start_rule(context, 'ScenarioDefinition')
650                self.start_rule(context, 'Scenario')
651                self.build(context, token)
652                return 12
653        if self.match_RuleLine(context, token):
654                self.end_rule(context, 'Step')
655                self.end_rule(context, 'Background')
656                self.start_rule(context, 'Rule')
657                self.start_rule(context, 'RuleHeader')
658                self.build(context, token)
659                return 22
660        if self.match_Comment(context, token):
661                self.build(context, token)
662                return 9
663        if self.match_Empty(context, token):
664                self.build(context, token)
665                return 9
666
667        state_comment = "State: 9 - GherkinDocument:0>Feature:1>Background:2>Step:0>#StepLine:0"
668        token.detach
669        expected_tokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
670        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
671        if (self.stop_at_first_error):
672            raise error
673        self.add_error(context, error)
674        return 9
675
676    # GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
677    def match_token_at_10(self, token, context):
678        if self.match_EOF(context, token):
679                self.end_rule(context, 'DataTable')
680                self.end_rule(context, 'Step')
681                self.end_rule(context, 'Background')
682                self.end_rule(context, 'Feature')
683                self.build(context, token)
684                return 41
685        if self.match_TableRow(context, token):
686                self.build(context, token)
687                return 10
688        if self.match_StepLine(context, token):
689                self.end_rule(context, 'DataTable')
690                self.end_rule(context, 'Step')
691                self.start_rule(context, 'Step')
692                self.build(context, token)
693                return 9
694        if self.match_TagLine(context, token):
695                self.end_rule(context, 'DataTable')
696                self.end_rule(context, 'Step')
697                self.end_rule(context, 'Background')
698                self.start_rule(context, 'ScenarioDefinition')
699                self.start_rule(context, 'Tags')
700                self.build(context, token)
701                return 11
702        if self.match_ScenarioLine(context, token):
703                self.end_rule(context, 'DataTable')
704                self.end_rule(context, 'Step')
705                self.end_rule(context, 'Background')
706                self.start_rule(context, 'ScenarioDefinition')
707                self.start_rule(context, 'Scenario')
708                self.build(context, token)
709                return 12
710        if self.match_RuleLine(context, token):
711                self.end_rule(context, 'DataTable')
712                self.end_rule(context, 'Step')
713                self.end_rule(context, 'Background')
714                self.start_rule(context, 'Rule')
715                self.start_rule(context, 'RuleHeader')
716                self.build(context, token)
717                return 22
718        if self.match_Comment(context, token):
719                self.build(context, token)
720                return 10
721        if self.match_Empty(context, token):
722                self.build(context, token)
723                return 10
724
725        state_comment = "State: 10 - GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0"
726        token.detach
727        expected_tokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
728        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
729        if (self.stop_at_first_error):
730            raise error
731        self.add_error(context, error)
732        return 10
733
734    # GherkinDocument:0>Feature:2>ScenarioDefinition:0>Tags:0>#TagLine:0
735    def match_token_at_11(self, token, context):
736        if self.match_TagLine(context, token):
737                self.build(context, token)
738                return 11
739        if self.match_ScenarioLine(context, token):
740                self.end_rule(context, 'Tags')
741                self.start_rule(context, 'Scenario')
742                self.build(context, token)
743                return 12
744        if self.match_Comment(context, token):
745                self.build(context, token)
746                return 11
747        if self.match_Empty(context, token):
748                self.build(context, token)
749                return 11
750
751        state_comment = "State: 11 - GherkinDocument:0>Feature:2>ScenarioDefinition:0>Tags:0>#TagLine:0"
752        token.detach
753        expected_tokens = ["#TagLine", "#ScenarioLine", "#Comment", "#Empty"]
754        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
755        if (self.stop_at_first_error):
756            raise error
757        self.add_error(context, error)
758        return 11
759
760    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0
761    def match_token_at_12(self, token, context):
762        if self.match_EOF(context, token):
763                self.end_rule(context, 'Scenario')
764                self.end_rule(context, 'ScenarioDefinition')
765                self.end_rule(context, 'Feature')
766                self.build(context, token)
767                return 41
768        if self.match_Empty(context, token):
769                self.build(context, token)
770                return 12
771        if self.match_Comment(context, token):
772                self.build(context, token)
773                return 14
774        if self.match_StepLine(context, token):
775                self.start_rule(context, 'Step')
776                self.build(context, token)
777                return 15
778        if self.match_TagLine(context, token):
779            if self.lookahead_0(context, token):
780                self.start_rule(context, 'ExamplesDefinition')
781                self.start_rule(context, 'Tags')
782                self.build(context, token)
783                return 17
784        if self.match_TagLine(context, token):
785                self.end_rule(context, 'Scenario')
786                self.end_rule(context, 'ScenarioDefinition')
787                self.start_rule(context, 'ScenarioDefinition')
788                self.start_rule(context, 'Tags')
789                self.build(context, token)
790                return 11
791        if self.match_ExamplesLine(context, token):
792                self.start_rule(context, 'ExamplesDefinition')
793                self.start_rule(context, 'Examples')
794                self.build(context, token)
795                return 18
796        if self.match_ScenarioLine(context, token):
797                self.end_rule(context, 'Scenario')
798                self.end_rule(context, 'ScenarioDefinition')
799                self.start_rule(context, 'ScenarioDefinition')
800                self.start_rule(context, 'Scenario')
801                self.build(context, token)
802                return 12
803        if self.match_RuleLine(context, token):
804                self.end_rule(context, 'Scenario')
805                self.end_rule(context, 'ScenarioDefinition')
806                self.start_rule(context, 'Rule')
807                self.start_rule(context, 'RuleHeader')
808                self.build(context, token)
809                return 22
810        if self.match_Other(context, token):
811                self.start_rule(context, 'Description')
812                self.build(context, token)
813                return 13
814
815        state_comment = "State: 12 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0"
816        token.detach
817        expected_tokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
818        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
819        if (self.stop_at_first_error):
820            raise error
821        self.add_error(context, error)
822        return 12
823
824    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0
825    def match_token_at_13(self, token, context):
826        if self.match_EOF(context, token):
827                self.end_rule(context, 'Description')
828                self.end_rule(context, 'Scenario')
829                self.end_rule(context, 'ScenarioDefinition')
830                self.end_rule(context, 'Feature')
831                self.build(context, token)
832                return 41
833        if self.match_Comment(context, token):
834                self.end_rule(context, 'Description')
835                self.build(context, token)
836                return 14
837        if self.match_StepLine(context, token):
838                self.end_rule(context, 'Description')
839                self.start_rule(context, 'Step')
840                self.build(context, token)
841                return 15
842        if self.match_TagLine(context, token):
843            if self.lookahead_0(context, token):
844                self.end_rule(context, 'Description')
845                self.start_rule(context, 'ExamplesDefinition')
846                self.start_rule(context, 'Tags')
847                self.build(context, token)
848                return 17
849        if self.match_TagLine(context, token):
850                self.end_rule(context, 'Description')
851                self.end_rule(context, 'Scenario')
852                self.end_rule(context, 'ScenarioDefinition')
853                self.start_rule(context, 'ScenarioDefinition')
854                self.start_rule(context, 'Tags')
855                self.build(context, token)
856                return 11
857        if self.match_ExamplesLine(context, token):
858                self.end_rule(context, 'Description')
859                self.start_rule(context, 'ExamplesDefinition')
860                self.start_rule(context, 'Examples')
861                self.build(context, token)
862                return 18
863        if self.match_ScenarioLine(context, token):
864                self.end_rule(context, 'Description')
865                self.end_rule(context, 'Scenario')
866                self.end_rule(context, 'ScenarioDefinition')
867                self.start_rule(context, 'ScenarioDefinition')
868                self.start_rule(context, 'Scenario')
869                self.build(context, token)
870                return 12
871        if self.match_RuleLine(context, token):
872                self.end_rule(context, 'Description')
873                self.end_rule(context, 'Scenario')
874                self.end_rule(context, 'ScenarioDefinition')
875                self.start_rule(context, 'Rule')
876                self.start_rule(context, 'RuleHeader')
877                self.build(context, token)
878                return 22
879        if self.match_Other(context, token):
880                self.build(context, token)
881                return 13
882
883        state_comment = "State: 13 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0"
884        token.detach
885        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
886        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
887        if (self.stop_at_first_error):
888            raise error
889        self.add_error(context, error)
890        return 13
891
892    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0
893    def match_token_at_14(self, token, context):
894        if self.match_EOF(context, token):
895                self.end_rule(context, 'Scenario')
896                self.end_rule(context, 'ScenarioDefinition')
897                self.end_rule(context, 'Feature')
898                self.build(context, token)
899                return 41
900        if self.match_Comment(context, token):
901                self.build(context, token)
902                return 14
903        if self.match_StepLine(context, token):
904                self.start_rule(context, 'Step')
905                self.build(context, token)
906                return 15
907        if self.match_TagLine(context, token):
908            if self.lookahead_0(context, token):
909                self.start_rule(context, 'ExamplesDefinition')
910                self.start_rule(context, 'Tags')
911                self.build(context, token)
912                return 17
913        if self.match_TagLine(context, token):
914                self.end_rule(context, 'Scenario')
915                self.end_rule(context, 'ScenarioDefinition')
916                self.start_rule(context, 'ScenarioDefinition')
917                self.start_rule(context, 'Tags')
918                self.build(context, token)
919                return 11
920        if self.match_ExamplesLine(context, token):
921                self.start_rule(context, 'ExamplesDefinition')
922                self.start_rule(context, 'Examples')
923                self.build(context, token)
924                return 18
925        if self.match_ScenarioLine(context, token):
926                self.end_rule(context, 'Scenario')
927                self.end_rule(context, 'ScenarioDefinition')
928                self.start_rule(context, 'ScenarioDefinition')
929                self.start_rule(context, 'Scenario')
930                self.build(context, token)
931                return 12
932        if self.match_RuleLine(context, token):
933                self.end_rule(context, 'Scenario')
934                self.end_rule(context, 'ScenarioDefinition')
935                self.start_rule(context, 'Rule')
936                self.start_rule(context, 'RuleHeader')
937                self.build(context, token)
938                return 22
939        if self.match_Empty(context, token):
940                self.build(context, token)
941                return 14
942
943        state_comment = "State: 14 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0"
944        token.detach
945        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"]
946        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
947        if (self.stop_at_first_error):
948            raise error
949        self.add_error(context, error)
950        return 14
951
952    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0
953    def match_token_at_15(self, token, context):
954        if self.match_EOF(context, token):
955                self.end_rule(context, 'Step')
956                self.end_rule(context, 'Scenario')
957                self.end_rule(context, 'ScenarioDefinition')
958                self.end_rule(context, 'Feature')
959                self.build(context, token)
960                return 41
961        if self.match_TableRow(context, token):
962                self.start_rule(context, 'DataTable')
963                self.build(context, token)
964                return 16
965        if self.match_DocStringSeparator(context, token):
966                self.start_rule(context, 'DocString')
967                self.build(context, token)
968                return 46
969        if self.match_StepLine(context, token):
970                self.end_rule(context, 'Step')
971                self.start_rule(context, 'Step')
972                self.build(context, token)
973                return 15
974        if self.match_TagLine(context, token):
975            if self.lookahead_0(context, token):
976                self.end_rule(context, 'Step')
977                self.start_rule(context, 'ExamplesDefinition')
978                self.start_rule(context, 'Tags')
979                self.build(context, token)
980                return 17
981        if self.match_TagLine(context, token):
982                self.end_rule(context, 'Step')
983                self.end_rule(context, 'Scenario')
984                self.end_rule(context, 'ScenarioDefinition')
985                self.start_rule(context, 'ScenarioDefinition')
986                self.start_rule(context, 'Tags')
987                self.build(context, token)
988                return 11
989        if self.match_ExamplesLine(context, token):
990                self.end_rule(context, 'Step')
991                self.start_rule(context, 'ExamplesDefinition')
992                self.start_rule(context, 'Examples')
993                self.build(context, token)
994                return 18
995        if self.match_ScenarioLine(context, token):
996                self.end_rule(context, 'Step')
997                self.end_rule(context, 'Scenario')
998                self.end_rule(context, 'ScenarioDefinition')
999                self.start_rule(context, 'ScenarioDefinition')
1000                self.start_rule(context, 'Scenario')
1001                self.build(context, token)
1002                return 12
1003        if self.match_RuleLine(context, token):
1004                self.end_rule(context, 'Step')
1005                self.end_rule(context, 'Scenario')
1006                self.end_rule(context, 'ScenarioDefinition')
1007                self.start_rule(context, 'Rule')
1008                self.start_rule(context, 'RuleHeader')
1009                self.build(context, token)
1010                return 22
1011        if self.match_Comment(context, token):
1012                self.build(context, token)
1013                return 15
1014        if self.match_Empty(context, token):
1015                self.build(context, token)
1016                return 15
1017
1018        state_comment = "State: 15 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0"
1019        token.detach
1020        expected_tokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
1021        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1022        if (self.stop_at_first_error):
1023            raise error
1024        self.add_error(context, error)
1025        return 15
1026
1027    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
1028    def match_token_at_16(self, token, context):
1029        if self.match_EOF(context, token):
1030                self.end_rule(context, 'DataTable')
1031                self.end_rule(context, 'Step')
1032                self.end_rule(context, 'Scenario')
1033                self.end_rule(context, 'ScenarioDefinition')
1034                self.end_rule(context, 'Feature')
1035                self.build(context, token)
1036                return 41
1037        if self.match_TableRow(context, token):
1038                self.build(context, token)
1039                return 16
1040        if self.match_StepLine(context, token):
1041                self.end_rule(context, 'DataTable')
1042                self.end_rule(context, 'Step')
1043                self.start_rule(context, 'Step')
1044                self.build(context, token)
1045                return 15
1046        if self.match_TagLine(context, token):
1047            if self.lookahead_0(context, token):
1048                self.end_rule(context, 'DataTable')
1049                self.end_rule(context, 'Step')
1050                self.start_rule(context, 'ExamplesDefinition')
1051                self.start_rule(context, 'Tags')
1052                self.build(context, token)
1053                return 17
1054        if self.match_TagLine(context, token):
1055                self.end_rule(context, 'DataTable')
1056                self.end_rule(context, 'Step')
1057                self.end_rule(context, 'Scenario')
1058                self.end_rule(context, 'ScenarioDefinition')
1059                self.start_rule(context, 'ScenarioDefinition')
1060                self.start_rule(context, 'Tags')
1061                self.build(context, token)
1062                return 11
1063        if self.match_ExamplesLine(context, token):
1064                self.end_rule(context, 'DataTable')
1065                self.end_rule(context, 'Step')
1066                self.start_rule(context, 'ExamplesDefinition')
1067                self.start_rule(context, 'Examples')
1068                self.build(context, token)
1069                return 18
1070        if self.match_ScenarioLine(context, token):
1071                self.end_rule(context, 'DataTable')
1072                self.end_rule(context, 'Step')
1073                self.end_rule(context, 'Scenario')
1074                self.end_rule(context, 'ScenarioDefinition')
1075                self.start_rule(context, 'ScenarioDefinition')
1076                self.start_rule(context, 'Scenario')
1077                self.build(context, token)
1078                return 12
1079        if self.match_RuleLine(context, token):
1080                self.end_rule(context, 'DataTable')
1081                self.end_rule(context, 'Step')
1082                self.end_rule(context, 'Scenario')
1083                self.end_rule(context, 'ScenarioDefinition')
1084                self.start_rule(context, 'Rule')
1085                self.start_rule(context, 'RuleHeader')
1086                self.build(context, token)
1087                return 22
1088        if self.match_Comment(context, token):
1089                self.build(context, token)
1090                return 16
1091        if self.match_Empty(context, token):
1092                self.build(context, token)
1093                return 16
1094
1095        state_comment = "State: 16 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0"
1096        token.detach
1097        expected_tokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
1098        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1099        if (self.stop_at_first_error):
1100            raise error
1101        self.add_error(context, error)
1102        return 16
1103
1104    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0
1105    def match_token_at_17(self, token, context):
1106        if self.match_TagLine(context, token):
1107                self.build(context, token)
1108                return 17
1109        if self.match_ExamplesLine(context, token):
1110                self.end_rule(context, 'Tags')
1111                self.start_rule(context, 'Examples')
1112                self.build(context, token)
1113                return 18
1114        if self.match_Comment(context, token):
1115                self.build(context, token)
1116                return 17
1117        if self.match_Empty(context, token):
1118                self.build(context, token)
1119                return 17
1120
1121        state_comment = "State: 17 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0"
1122        token.detach
1123        expected_tokens = ["#TagLine", "#ExamplesLine", "#Comment", "#Empty"]
1124        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1125        if (self.stop_at_first_error):
1126            raise error
1127        self.add_error(context, error)
1128        return 17
1129
1130    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0
1131    def match_token_at_18(self, token, context):
1132        if self.match_EOF(context, token):
1133                self.end_rule(context, 'Examples')
1134                self.end_rule(context, 'ExamplesDefinition')
1135                self.end_rule(context, 'Scenario')
1136                self.end_rule(context, 'ScenarioDefinition')
1137                self.end_rule(context, 'Feature')
1138                self.build(context, token)
1139                return 41
1140        if self.match_Empty(context, token):
1141                self.build(context, token)
1142                return 18
1143        if self.match_Comment(context, token):
1144                self.build(context, token)
1145                return 20
1146        if self.match_TableRow(context, token):
1147                self.start_rule(context, 'ExamplesTable')
1148                self.build(context, token)
1149                return 21
1150        if self.match_TagLine(context, token):
1151            if self.lookahead_0(context, token):
1152                self.end_rule(context, 'Examples')
1153                self.end_rule(context, 'ExamplesDefinition')
1154                self.start_rule(context, 'ExamplesDefinition')
1155                self.start_rule(context, 'Tags')
1156                self.build(context, token)
1157                return 17
1158        if self.match_TagLine(context, token):
1159                self.end_rule(context, 'Examples')
1160                self.end_rule(context, 'ExamplesDefinition')
1161                self.end_rule(context, 'Scenario')
1162                self.end_rule(context, 'ScenarioDefinition')
1163                self.start_rule(context, 'ScenarioDefinition')
1164                self.start_rule(context, 'Tags')
1165                self.build(context, token)
1166                return 11
1167        if self.match_ExamplesLine(context, token):
1168                self.end_rule(context, 'Examples')
1169                self.end_rule(context, 'ExamplesDefinition')
1170                self.start_rule(context, 'ExamplesDefinition')
1171                self.start_rule(context, 'Examples')
1172                self.build(context, token)
1173                return 18
1174        if self.match_ScenarioLine(context, token):
1175                self.end_rule(context, 'Examples')
1176                self.end_rule(context, 'ExamplesDefinition')
1177                self.end_rule(context, 'Scenario')
1178                self.end_rule(context, 'ScenarioDefinition')
1179                self.start_rule(context, 'ScenarioDefinition')
1180                self.start_rule(context, 'Scenario')
1181                self.build(context, token)
1182                return 12
1183        if self.match_RuleLine(context, token):
1184                self.end_rule(context, 'Examples')
1185                self.end_rule(context, 'ExamplesDefinition')
1186                self.end_rule(context, 'Scenario')
1187                self.end_rule(context, 'ScenarioDefinition')
1188                self.start_rule(context, 'Rule')
1189                self.start_rule(context, 'RuleHeader')
1190                self.build(context, token)
1191                return 22
1192        if self.match_Other(context, token):
1193                self.start_rule(context, 'Description')
1194                self.build(context, token)
1195                return 19
1196
1197        state_comment = "State: 18 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0"
1198        token.detach
1199        expected_tokens = ["#EOF", "#Empty", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
1200        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1201        if (self.stop_at_first_error):
1202            raise error
1203        self.add_error(context, error)
1204        return 18
1205
1206    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0
1207    def match_token_at_19(self, token, context):
1208        if self.match_EOF(context, token):
1209                self.end_rule(context, 'Description')
1210                self.end_rule(context, 'Examples')
1211                self.end_rule(context, 'ExamplesDefinition')
1212                self.end_rule(context, 'Scenario')
1213                self.end_rule(context, 'ScenarioDefinition')
1214                self.end_rule(context, 'Feature')
1215                self.build(context, token)
1216                return 41
1217        if self.match_Comment(context, token):
1218                self.end_rule(context, 'Description')
1219                self.build(context, token)
1220                return 20
1221        if self.match_TableRow(context, token):
1222                self.end_rule(context, 'Description')
1223                self.start_rule(context, 'ExamplesTable')
1224                self.build(context, token)
1225                return 21
1226        if self.match_TagLine(context, token):
1227            if self.lookahead_0(context, token):
1228                self.end_rule(context, 'Description')
1229                self.end_rule(context, 'Examples')
1230                self.end_rule(context, 'ExamplesDefinition')
1231                self.start_rule(context, 'ExamplesDefinition')
1232                self.start_rule(context, 'Tags')
1233                self.build(context, token)
1234                return 17
1235        if self.match_TagLine(context, token):
1236                self.end_rule(context, 'Description')
1237                self.end_rule(context, 'Examples')
1238                self.end_rule(context, 'ExamplesDefinition')
1239                self.end_rule(context, 'Scenario')
1240                self.end_rule(context, 'ScenarioDefinition')
1241                self.start_rule(context, 'ScenarioDefinition')
1242                self.start_rule(context, 'Tags')
1243                self.build(context, token)
1244                return 11
1245        if self.match_ExamplesLine(context, token):
1246                self.end_rule(context, 'Description')
1247                self.end_rule(context, 'Examples')
1248                self.end_rule(context, 'ExamplesDefinition')
1249                self.start_rule(context, 'ExamplesDefinition')
1250                self.start_rule(context, 'Examples')
1251                self.build(context, token)
1252                return 18
1253        if self.match_ScenarioLine(context, token):
1254                self.end_rule(context, 'Description')
1255                self.end_rule(context, 'Examples')
1256                self.end_rule(context, 'ExamplesDefinition')
1257                self.end_rule(context, 'Scenario')
1258                self.end_rule(context, 'ScenarioDefinition')
1259                self.start_rule(context, 'ScenarioDefinition')
1260                self.start_rule(context, 'Scenario')
1261                self.build(context, token)
1262                return 12
1263        if self.match_RuleLine(context, token):
1264                self.end_rule(context, 'Description')
1265                self.end_rule(context, 'Examples')
1266                self.end_rule(context, 'ExamplesDefinition')
1267                self.end_rule(context, 'Scenario')
1268                self.end_rule(context, 'ScenarioDefinition')
1269                self.start_rule(context, 'Rule')
1270                self.start_rule(context, 'RuleHeader')
1271                self.build(context, token)
1272                return 22
1273        if self.match_Other(context, token):
1274                self.build(context, token)
1275                return 19
1276
1277        state_comment = "State: 19 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0"
1278        token.detach
1279        expected_tokens = ["#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
1280        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1281        if (self.stop_at_first_error):
1282            raise error
1283        self.add_error(context, error)
1284        return 19
1285
1286    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0
1287    def match_token_at_20(self, token, context):
1288        if self.match_EOF(context, token):
1289                self.end_rule(context, 'Examples')
1290                self.end_rule(context, 'ExamplesDefinition')
1291                self.end_rule(context, 'Scenario')
1292                self.end_rule(context, 'ScenarioDefinition')
1293                self.end_rule(context, 'Feature')
1294                self.build(context, token)
1295                return 41
1296        if self.match_Comment(context, token):
1297                self.build(context, token)
1298                return 20
1299        if self.match_TableRow(context, token):
1300                self.start_rule(context, 'ExamplesTable')
1301                self.build(context, token)
1302                return 21
1303        if self.match_TagLine(context, token):
1304            if self.lookahead_0(context, token):
1305                self.end_rule(context, 'Examples')
1306                self.end_rule(context, 'ExamplesDefinition')
1307                self.start_rule(context, 'ExamplesDefinition')
1308                self.start_rule(context, 'Tags')
1309                self.build(context, token)
1310                return 17
1311        if self.match_TagLine(context, token):
1312                self.end_rule(context, 'Examples')
1313                self.end_rule(context, 'ExamplesDefinition')
1314                self.end_rule(context, 'Scenario')
1315                self.end_rule(context, 'ScenarioDefinition')
1316                self.start_rule(context, 'ScenarioDefinition')
1317                self.start_rule(context, 'Tags')
1318                self.build(context, token)
1319                return 11
1320        if self.match_ExamplesLine(context, token):
1321                self.end_rule(context, 'Examples')
1322                self.end_rule(context, 'ExamplesDefinition')
1323                self.start_rule(context, 'ExamplesDefinition')
1324                self.start_rule(context, 'Examples')
1325                self.build(context, token)
1326                return 18
1327        if self.match_ScenarioLine(context, token):
1328                self.end_rule(context, 'Examples')
1329                self.end_rule(context, 'ExamplesDefinition')
1330                self.end_rule(context, 'Scenario')
1331                self.end_rule(context, 'ScenarioDefinition')
1332                self.start_rule(context, 'ScenarioDefinition')
1333                self.start_rule(context, 'Scenario')
1334                self.build(context, token)
1335                return 12
1336        if self.match_RuleLine(context, token):
1337                self.end_rule(context, 'Examples')
1338                self.end_rule(context, 'ExamplesDefinition')
1339                self.end_rule(context, 'Scenario')
1340                self.end_rule(context, 'ScenarioDefinition')
1341                self.start_rule(context, 'Rule')
1342                self.start_rule(context, 'RuleHeader')
1343                self.build(context, token)
1344                return 22
1345        if self.match_Empty(context, token):
1346                self.build(context, token)
1347                return 20
1348
1349        state_comment = "State: 20 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0"
1350        token.detach
1351        expected_tokens = ["#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"]
1352        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1353        if (self.stop_at_first_error):
1354            raise error
1355        self.add_error(context, error)
1356        return 20
1357
1358    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0
1359    def match_token_at_21(self, token, context):
1360        if self.match_EOF(context, token):
1361                self.end_rule(context, 'ExamplesTable')
1362                self.end_rule(context, 'Examples')
1363                self.end_rule(context, 'ExamplesDefinition')
1364                self.end_rule(context, 'Scenario')
1365                self.end_rule(context, 'ScenarioDefinition')
1366                self.end_rule(context, 'Feature')
1367                self.build(context, token)
1368                return 41
1369        if self.match_TableRow(context, token):
1370                self.build(context, token)
1371                return 21
1372        if self.match_TagLine(context, token):
1373            if self.lookahead_0(context, token):
1374                self.end_rule(context, 'ExamplesTable')
1375                self.end_rule(context, 'Examples')
1376                self.end_rule(context, 'ExamplesDefinition')
1377                self.start_rule(context, 'ExamplesDefinition')
1378                self.start_rule(context, 'Tags')
1379                self.build(context, token)
1380                return 17
1381        if self.match_TagLine(context, token):
1382                self.end_rule(context, 'ExamplesTable')
1383                self.end_rule(context, 'Examples')
1384                self.end_rule(context, 'ExamplesDefinition')
1385                self.end_rule(context, 'Scenario')
1386                self.end_rule(context, 'ScenarioDefinition')
1387                self.start_rule(context, 'ScenarioDefinition')
1388                self.start_rule(context, 'Tags')
1389                self.build(context, token)
1390                return 11
1391        if self.match_ExamplesLine(context, token):
1392                self.end_rule(context, 'ExamplesTable')
1393                self.end_rule(context, 'Examples')
1394                self.end_rule(context, 'ExamplesDefinition')
1395                self.start_rule(context, 'ExamplesDefinition')
1396                self.start_rule(context, 'Examples')
1397                self.build(context, token)
1398                return 18
1399        if self.match_ScenarioLine(context, token):
1400                self.end_rule(context, 'ExamplesTable')
1401                self.end_rule(context, 'Examples')
1402                self.end_rule(context, 'ExamplesDefinition')
1403                self.end_rule(context, 'Scenario')
1404                self.end_rule(context, 'ScenarioDefinition')
1405                self.start_rule(context, 'ScenarioDefinition')
1406                self.start_rule(context, 'Scenario')
1407                self.build(context, token)
1408                return 12
1409        if self.match_RuleLine(context, token):
1410                self.end_rule(context, 'ExamplesTable')
1411                self.end_rule(context, 'Examples')
1412                self.end_rule(context, 'ExamplesDefinition')
1413                self.end_rule(context, 'Scenario')
1414                self.end_rule(context, 'ScenarioDefinition')
1415                self.start_rule(context, 'Rule')
1416                self.start_rule(context, 'RuleHeader')
1417                self.build(context, token)
1418                return 22
1419        if self.match_Comment(context, token):
1420                self.build(context, token)
1421                return 21
1422        if self.match_Empty(context, token):
1423                self.build(context, token)
1424                return 21
1425
1426        state_comment = "State: 21 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0"
1427        token.detach
1428        expected_tokens = ["#EOF", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
1429        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1430        if (self.stop_at_first_error):
1431            raise error
1432        self.add_error(context, error)
1433        return 21
1434
1435    # GherkinDocument:0>Feature:3>Rule:0>RuleHeader:0>#RuleLine:0
1436    def match_token_at_22(self, token, context):
1437        if self.match_EOF(context, token):
1438                self.end_rule(context, 'RuleHeader')
1439                self.end_rule(context, 'Rule')
1440                self.end_rule(context, 'Feature')
1441                self.build(context, token)
1442                return 41
1443        if self.match_Empty(context, token):
1444                self.build(context, token)
1445                return 22
1446        if self.match_Comment(context, token):
1447                self.build(context, token)
1448                return 24
1449        if self.match_BackgroundLine(context, token):
1450                self.end_rule(context, 'RuleHeader')
1451                self.start_rule(context, 'Background')
1452                self.build(context, token)
1453                return 25
1454        if self.match_TagLine(context, token):
1455                self.end_rule(context, 'RuleHeader')
1456                self.start_rule(context, 'ScenarioDefinition')
1457                self.start_rule(context, 'Tags')
1458                self.build(context, token)
1459                return 30
1460        if self.match_ScenarioLine(context, token):
1461                self.end_rule(context, 'RuleHeader')
1462                self.start_rule(context, 'ScenarioDefinition')
1463                self.start_rule(context, 'Scenario')
1464                self.build(context, token)
1465                return 31
1466        if self.match_RuleLine(context, token):
1467                self.end_rule(context, 'RuleHeader')
1468                self.end_rule(context, 'Rule')
1469                self.start_rule(context, 'Rule')
1470                self.start_rule(context, 'RuleHeader')
1471                self.build(context, token)
1472                return 22
1473        if self.match_Other(context, token):
1474                self.start_rule(context, 'Description')
1475                self.build(context, token)
1476                return 23
1477
1478        state_comment = "State: 22 - GherkinDocument:0>Feature:3>Rule:0>RuleHeader:0>#RuleLine:0"
1479        token.detach
1480        expected_tokens = ["#EOF", "#Empty", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
1481        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1482        if (self.stop_at_first_error):
1483            raise error
1484        self.add_error(context, error)
1485        return 22
1486
1487    # GherkinDocument:0>Feature:3>Rule:0>RuleHeader:1>DescriptionHelper:1>Description:0>#Other:0
1488    def match_token_at_23(self, token, context):
1489        if self.match_EOF(context, token):
1490                self.end_rule(context, 'Description')
1491                self.end_rule(context, 'RuleHeader')
1492                self.end_rule(context, 'Rule')
1493                self.end_rule(context, 'Feature')
1494                self.build(context, token)
1495                return 41
1496        if self.match_Comment(context, token):
1497                self.end_rule(context, 'Description')
1498                self.build(context, token)
1499                return 24
1500        if self.match_BackgroundLine(context, token):
1501                self.end_rule(context, 'Description')
1502                self.end_rule(context, 'RuleHeader')
1503                self.start_rule(context, 'Background')
1504                self.build(context, token)
1505                return 25
1506        if self.match_TagLine(context, token):
1507                self.end_rule(context, 'Description')
1508                self.end_rule(context, 'RuleHeader')
1509                self.start_rule(context, 'ScenarioDefinition')
1510                self.start_rule(context, 'Tags')
1511                self.build(context, token)
1512                return 30
1513        if self.match_ScenarioLine(context, token):
1514                self.end_rule(context, 'Description')
1515                self.end_rule(context, 'RuleHeader')
1516                self.start_rule(context, 'ScenarioDefinition')
1517                self.start_rule(context, 'Scenario')
1518                self.build(context, token)
1519                return 31
1520        if self.match_RuleLine(context, token):
1521                self.end_rule(context, 'Description')
1522                self.end_rule(context, 'RuleHeader')
1523                self.end_rule(context, 'Rule')
1524                self.start_rule(context, 'Rule')
1525                self.start_rule(context, 'RuleHeader')
1526                self.build(context, token)
1527                return 22
1528        if self.match_Other(context, token):
1529                self.build(context, token)
1530                return 23
1531
1532        state_comment = "State: 23 - GherkinDocument:0>Feature:3>Rule:0>RuleHeader:1>DescriptionHelper:1>Description:0>#Other:0"
1533        token.detach
1534        expected_tokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
1535        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1536        if (self.stop_at_first_error):
1537            raise error
1538        self.add_error(context, error)
1539        return 23
1540
1541    # GherkinDocument:0>Feature:3>Rule:0>RuleHeader:1>DescriptionHelper:2>#Comment:0
1542    def match_token_at_24(self, token, context):
1543        if self.match_EOF(context, token):
1544                self.end_rule(context, 'RuleHeader')
1545                self.end_rule(context, 'Rule')
1546                self.end_rule(context, 'Feature')
1547                self.build(context, token)
1548                return 41
1549        if self.match_Comment(context, token):
1550                self.build(context, token)
1551                return 24
1552        if self.match_BackgroundLine(context, token):
1553                self.end_rule(context, 'RuleHeader')
1554                self.start_rule(context, 'Background')
1555                self.build(context, token)
1556                return 25
1557        if self.match_TagLine(context, token):
1558                self.end_rule(context, 'RuleHeader')
1559                self.start_rule(context, 'ScenarioDefinition')
1560                self.start_rule(context, 'Tags')
1561                self.build(context, token)
1562                return 30
1563        if self.match_ScenarioLine(context, token):
1564                self.end_rule(context, 'RuleHeader')
1565                self.start_rule(context, 'ScenarioDefinition')
1566                self.start_rule(context, 'Scenario')
1567                self.build(context, token)
1568                return 31
1569        if self.match_RuleLine(context, token):
1570                self.end_rule(context, 'RuleHeader')
1571                self.end_rule(context, 'Rule')
1572                self.start_rule(context, 'Rule')
1573                self.start_rule(context, 'RuleHeader')
1574                self.build(context, token)
1575                return 22
1576        if self.match_Empty(context, token):
1577                self.build(context, token)
1578                return 24
1579
1580        state_comment = "State: 24 - GherkinDocument:0>Feature:3>Rule:0>RuleHeader:1>DescriptionHelper:2>#Comment:0"
1581        token.detach
1582        expected_tokens = ["#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"]
1583        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1584        if (self.stop_at_first_error):
1585            raise error
1586        self.add_error(context, error)
1587        return 24
1588
1589    # GherkinDocument:0>Feature:3>Rule:1>Background:0>#BackgroundLine:0
1590    def match_token_at_25(self, token, context):
1591        if self.match_EOF(context, token):
1592                self.end_rule(context, 'Background')
1593                self.end_rule(context, 'Rule')
1594                self.end_rule(context, 'Feature')
1595                self.build(context, token)
1596                return 41
1597        if self.match_Empty(context, token):
1598                self.build(context, token)
1599                return 25
1600        if self.match_Comment(context, token):
1601                self.build(context, token)
1602                return 27
1603        if self.match_StepLine(context, token):
1604                self.start_rule(context, 'Step')
1605                self.build(context, token)
1606                return 28
1607        if self.match_TagLine(context, token):
1608                self.end_rule(context, 'Background')
1609                self.start_rule(context, 'ScenarioDefinition')
1610                self.start_rule(context, 'Tags')
1611                self.build(context, token)
1612                return 30
1613        if self.match_ScenarioLine(context, token):
1614                self.end_rule(context, 'Background')
1615                self.start_rule(context, 'ScenarioDefinition')
1616                self.start_rule(context, 'Scenario')
1617                self.build(context, token)
1618                return 31
1619        if self.match_RuleLine(context, token):
1620                self.end_rule(context, 'Background')
1621                self.end_rule(context, 'Rule')
1622                self.start_rule(context, 'Rule')
1623                self.start_rule(context, 'RuleHeader')
1624                self.build(context, token)
1625                return 22
1626        if self.match_Other(context, token):
1627                self.start_rule(context, 'Description')
1628                self.build(context, token)
1629                return 26
1630
1631        state_comment = "State: 25 - GherkinDocument:0>Feature:3>Rule:1>Background:0>#BackgroundLine:0"
1632        token.detach
1633        expected_tokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
1634        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1635        if (self.stop_at_first_error):
1636            raise error
1637        self.add_error(context, error)
1638        return 25
1639
1640    # GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:1>Description:0>#Other:0
1641    def match_token_at_26(self, token, context):
1642        if self.match_EOF(context, token):
1643                self.end_rule(context, 'Description')
1644                self.end_rule(context, 'Background')
1645                self.end_rule(context, 'Rule')
1646                self.end_rule(context, 'Feature')
1647                self.build(context, token)
1648                return 41
1649        if self.match_Comment(context, token):
1650                self.end_rule(context, 'Description')
1651                self.build(context, token)
1652                return 27
1653        if self.match_StepLine(context, token):
1654                self.end_rule(context, 'Description')
1655                self.start_rule(context, 'Step')
1656                self.build(context, token)
1657                return 28
1658        if self.match_TagLine(context, token):
1659                self.end_rule(context, 'Description')
1660                self.end_rule(context, 'Background')
1661                self.start_rule(context, 'ScenarioDefinition')
1662                self.start_rule(context, 'Tags')
1663                self.build(context, token)
1664                return 30
1665        if self.match_ScenarioLine(context, token):
1666                self.end_rule(context, 'Description')
1667                self.end_rule(context, 'Background')
1668                self.start_rule(context, 'ScenarioDefinition')
1669                self.start_rule(context, 'Scenario')
1670                self.build(context, token)
1671                return 31
1672        if self.match_RuleLine(context, token):
1673                self.end_rule(context, 'Description')
1674                self.end_rule(context, 'Background')
1675                self.end_rule(context, 'Rule')
1676                self.start_rule(context, 'Rule')
1677                self.start_rule(context, 'RuleHeader')
1678                self.build(context, token)
1679                return 22
1680        if self.match_Other(context, token):
1681                self.build(context, token)
1682                return 26
1683
1684        state_comment = "State: 26 - GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:1>Description:0>#Other:0"
1685        token.detach
1686        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"]
1687        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1688        if (self.stop_at_first_error):
1689            raise error
1690        self.add_error(context, error)
1691        return 26
1692
1693    # GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:2>#Comment:0
1694    def match_token_at_27(self, token, context):
1695        if self.match_EOF(context, token):
1696                self.end_rule(context, 'Background')
1697                self.end_rule(context, 'Rule')
1698                self.end_rule(context, 'Feature')
1699                self.build(context, token)
1700                return 41
1701        if self.match_Comment(context, token):
1702                self.build(context, token)
1703                return 27
1704        if self.match_StepLine(context, token):
1705                self.start_rule(context, 'Step')
1706                self.build(context, token)
1707                return 28
1708        if self.match_TagLine(context, token):
1709                self.end_rule(context, 'Background')
1710                self.start_rule(context, 'ScenarioDefinition')
1711                self.start_rule(context, 'Tags')
1712                self.build(context, token)
1713                return 30
1714        if self.match_ScenarioLine(context, token):
1715                self.end_rule(context, 'Background')
1716                self.start_rule(context, 'ScenarioDefinition')
1717                self.start_rule(context, 'Scenario')
1718                self.build(context, token)
1719                return 31
1720        if self.match_RuleLine(context, token):
1721                self.end_rule(context, 'Background')
1722                self.end_rule(context, 'Rule')
1723                self.start_rule(context, 'Rule')
1724                self.start_rule(context, 'RuleHeader')
1725                self.build(context, token)
1726                return 22
1727        if self.match_Empty(context, token):
1728                self.build(context, token)
1729                return 27
1730
1731        state_comment = "State: 27 - GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:2>#Comment:0"
1732        token.detach
1733        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"]
1734        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1735        if (self.stop_at_first_error):
1736            raise error
1737        self.add_error(context, error)
1738        return 27
1739
1740    # GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:0>#StepLine:0
1741    def match_token_at_28(self, token, context):
1742        if self.match_EOF(context, token):
1743                self.end_rule(context, 'Step')
1744                self.end_rule(context, 'Background')
1745                self.end_rule(context, 'Rule')
1746                self.end_rule(context, 'Feature')
1747                self.build(context, token)
1748                return 41
1749        if self.match_TableRow(context, token):
1750                self.start_rule(context, 'DataTable')
1751                self.build(context, token)
1752                return 29
1753        if self.match_DocStringSeparator(context, token):
1754                self.start_rule(context, 'DocString')
1755                self.build(context, token)
1756                return 44
1757        if self.match_StepLine(context, token):
1758                self.end_rule(context, 'Step')
1759                self.start_rule(context, 'Step')
1760                self.build(context, token)
1761                return 28
1762        if self.match_TagLine(context, token):
1763                self.end_rule(context, 'Step')
1764                self.end_rule(context, 'Background')
1765                self.start_rule(context, 'ScenarioDefinition')
1766                self.start_rule(context, 'Tags')
1767                self.build(context, token)
1768                return 30
1769        if self.match_ScenarioLine(context, token):
1770                self.end_rule(context, 'Step')
1771                self.end_rule(context, 'Background')
1772                self.start_rule(context, 'ScenarioDefinition')
1773                self.start_rule(context, 'Scenario')
1774                self.build(context, token)
1775                return 31
1776        if self.match_RuleLine(context, token):
1777                self.end_rule(context, 'Step')
1778                self.end_rule(context, 'Background')
1779                self.end_rule(context, 'Rule')
1780                self.start_rule(context, 'Rule')
1781                self.start_rule(context, 'RuleHeader')
1782                self.build(context, token)
1783                return 22
1784        if self.match_Comment(context, token):
1785                self.build(context, token)
1786                return 28
1787        if self.match_Empty(context, token):
1788                self.build(context, token)
1789                return 28
1790
1791        state_comment = "State: 28 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:0>#StepLine:0"
1792        token.detach
1793        expected_tokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
1794        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1795        if (self.stop_at_first_error):
1796            raise error
1797        self.add_error(context, error)
1798        return 28
1799
1800    # GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
1801    def match_token_at_29(self, token, context):
1802        if self.match_EOF(context, token):
1803                self.end_rule(context, 'DataTable')
1804                self.end_rule(context, 'Step')
1805                self.end_rule(context, 'Background')
1806                self.end_rule(context, 'Rule')
1807                self.end_rule(context, 'Feature')
1808                self.build(context, token)
1809                return 41
1810        if self.match_TableRow(context, token):
1811                self.build(context, token)
1812                return 29
1813        if self.match_StepLine(context, token):
1814                self.end_rule(context, 'DataTable')
1815                self.end_rule(context, 'Step')
1816                self.start_rule(context, 'Step')
1817                self.build(context, token)
1818                return 28
1819        if self.match_TagLine(context, token):
1820                self.end_rule(context, 'DataTable')
1821                self.end_rule(context, 'Step')
1822                self.end_rule(context, 'Background')
1823                self.start_rule(context, 'ScenarioDefinition')
1824                self.start_rule(context, 'Tags')
1825                self.build(context, token)
1826                return 30
1827        if self.match_ScenarioLine(context, token):
1828                self.end_rule(context, 'DataTable')
1829                self.end_rule(context, 'Step')
1830                self.end_rule(context, 'Background')
1831                self.start_rule(context, 'ScenarioDefinition')
1832                self.start_rule(context, 'Scenario')
1833                self.build(context, token)
1834                return 31
1835        if self.match_RuleLine(context, token):
1836                self.end_rule(context, 'DataTable')
1837                self.end_rule(context, 'Step')
1838                self.end_rule(context, 'Background')
1839                self.end_rule(context, 'Rule')
1840                self.start_rule(context, 'Rule')
1841                self.start_rule(context, 'RuleHeader')
1842                self.build(context, token)
1843                return 22
1844        if self.match_Comment(context, token):
1845                self.build(context, token)
1846                return 29
1847        if self.match_Empty(context, token):
1848                self.build(context, token)
1849                return 29
1850
1851        state_comment = "State: 29 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0"
1852        token.detach
1853        expected_tokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
1854        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1855        if (self.stop_at_first_error):
1856            raise error
1857        self.add_error(context, error)
1858        return 29
1859
1860    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:0>Tags:0>#TagLine:0
1861    def match_token_at_30(self, token, context):
1862        if self.match_TagLine(context, token):
1863                self.build(context, token)
1864                return 30
1865        if self.match_ScenarioLine(context, token):
1866                self.end_rule(context, 'Tags')
1867                self.start_rule(context, 'Scenario')
1868                self.build(context, token)
1869                return 31
1870        if self.match_Comment(context, token):
1871                self.build(context, token)
1872                return 30
1873        if self.match_Empty(context, token):
1874                self.build(context, token)
1875                return 30
1876
1877        state_comment = "State: 30 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:0>Tags:0>#TagLine:0"
1878        token.detach
1879        expected_tokens = ["#TagLine", "#ScenarioLine", "#Comment", "#Empty"]
1880        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1881        if (self.stop_at_first_error):
1882            raise error
1883        self.add_error(context, error)
1884        return 30
1885
1886    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0
1887    def match_token_at_31(self, token, context):
1888        if self.match_EOF(context, token):
1889                self.end_rule(context, 'Scenario')
1890                self.end_rule(context, 'ScenarioDefinition')
1891                self.end_rule(context, 'Rule')
1892                self.end_rule(context, 'Feature')
1893                self.build(context, token)
1894                return 41
1895        if self.match_Empty(context, token):
1896                self.build(context, token)
1897                return 31
1898        if self.match_Comment(context, token):
1899                self.build(context, token)
1900                return 33
1901        if self.match_StepLine(context, token):
1902                self.start_rule(context, 'Step')
1903                self.build(context, token)
1904                return 34
1905        if self.match_TagLine(context, token):
1906            if self.lookahead_0(context, token):
1907                self.start_rule(context, 'ExamplesDefinition')
1908                self.start_rule(context, 'Tags')
1909                self.build(context, token)
1910                return 36
1911        if self.match_TagLine(context, token):
1912                self.end_rule(context, 'Scenario')
1913                self.end_rule(context, 'ScenarioDefinition')
1914                self.start_rule(context, 'ScenarioDefinition')
1915                self.start_rule(context, 'Tags')
1916                self.build(context, token)
1917                return 30
1918        if self.match_ExamplesLine(context, token):
1919                self.start_rule(context, 'ExamplesDefinition')
1920                self.start_rule(context, 'Examples')
1921                self.build(context, token)
1922                return 37
1923        if self.match_ScenarioLine(context, token):
1924                self.end_rule(context, 'Scenario')
1925                self.end_rule(context, 'ScenarioDefinition')
1926                self.start_rule(context, 'ScenarioDefinition')
1927                self.start_rule(context, 'Scenario')
1928                self.build(context, token)
1929                return 31
1930        if self.match_RuleLine(context, token):
1931                self.end_rule(context, 'Scenario')
1932                self.end_rule(context, 'ScenarioDefinition')
1933                self.end_rule(context, 'Rule')
1934                self.start_rule(context, 'Rule')
1935                self.start_rule(context, 'RuleHeader')
1936                self.build(context, token)
1937                return 22
1938        if self.match_Other(context, token):
1939                self.start_rule(context, 'Description')
1940                self.build(context, token)
1941                return 32
1942
1943        state_comment = "State: 31 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0"
1944        token.detach
1945        expected_tokens = ["#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
1946        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
1947        if (self.stop_at_first_error):
1948            raise error
1949        self.add_error(context, error)
1950        return 31
1951
1952    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0
1953    def match_token_at_32(self, token, context):
1954        if self.match_EOF(context, token):
1955                self.end_rule(context, 'Description')
1956                self.end_rule(context, 'Scenario')
1957                self.end_rule(context, 'ScenarioDefinition')
1958                self.end_rule(context, 'Rule')
1959                self.end_rule(context, 'Feature')
1960                self.build(context, token)
1961                return 41
1962        if self.match_Comment(context, token):
1963                self.end_rule(context, 'Description')
1964                self.build(context, token)
1965                return 33
1966        if self.match_StepLine(context, token):
1967                self.end_rule(context, 'Description')
1968                self.start_rule(context, 'Step')
1969                self.build(context, token)
1970                return 34
1971        if self.match_TagLine(context, token):
1972            if self.lookahead_0(context, token):
1973                self.end_rule(context, 'Description')
1974                self.start_rule(context, 'ExamplesDefinition')
1975                self.start_rule(context, 'Tags')
1976                self.build(context, token)
1977                return 36
1978        if self.match_TagLine(context, token):
1979                self.end_rule(context, 'Description')
1980                self.end_rule(context, 'Scenario')
1981                self.end_rule(context, 'ScenarioDefinition')
1982                self.start_rule(context, 'ScenarioDefinition')
1983                self.start_rule(context, 'Tags')
1984                self.build(context, token)
1985                return 30
1986        if self.match_ExamplesLine(context, token):
1987                self.end_rule(context, 'Description')
1988                self.start_rule(context, 'ExamplesDefinition')
1989                self.start_rule(context, 'Examples')
1990                self.build(context, token)
1991                return 37
1992        if self.match_ScenarioLine(context, token):
1993                self.end_rule(context, 'Description')
1994                self.end_rule(context, 'Scenario')
1995                self.end_rule(context, 'ScenarioDefinition')
1996                self.start_rule(context, 'ScenarioDefinition')
1997                self.start_rule(context, 'Scenario')
1998                self.build(context, token)
1999                return 31
2000        if self.match_RuleLine(context, token):
2001                self.end_rule(context, 'Description')
2002                self.end_rule(context, 'Scenario')
2003                self.end_rule(context, 'ScenarioDefinition')
2004                self.end_rule(context, 'Rule')
2005                self.start_rule(context, 'Rule')
2006                self.start_rule(context, 'RuleHeader')
2007                self.build(context, token)
2008                return 22
2009        if self.match_Other(context, token):
2010                self.build(context, token)
2011                return 32
2012
2013        state_comment = "State: 32 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0"
2014        token.detach
2015        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
2016        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2017        if (self.stop_at_first_error):
2018            raise error
2019        self.add_error(context, error)
2020        return 32
2021
2022    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0
2023    def match_token_at_33(self, token, context):
2024        if self.match_EOF(context, token):
2025                self.end_rule(context, 'Scenario')
2026                self.end_rule(context, 'ScenarioDefinition')
2027                self.end_rule(context, 'Rule')
2028                self.end_rule(context, 'Feature')
2029                self.build(context, token)
2030                return 41
2031        if self.match_Comment(context, token):
2032                self.build(context, token)
2033                return 33
2034        if self.match_StepLine(context, token):
2035                self.start_rule(context, 'Step')
2036                self.build(context, token)
2037                return 34
2038        if self.match_TagLine(context, token):
2039            if self.lookahead_0(context, token):
2040                self.start_rule(context, 'ExamplesDefinition')
2041                self.start_rule(context, 'Tags')
2042                self.build(context, token)
2043                return 36
2044        if self.match_TagLine(context, token):
2045                self.end_rule(context, 'Scenario')
2046                self.end_rule(context, 'ScenarioDefinition')
2047                self.start_rule(context, 'ScenarioDefinition')
2048                self.start_rule(context, 'Tags')
2049                self.build(context, token)
2050                return 30
2051        if self.match_ExamplesLine(context, token):
2052                self.start_rule(context, 'ExamplesDefinition')
2053                self.start_rule(context, 'Examples')
2054                self.build(context, token)
2055                return 37
2056        if self.match_ScenarioLine(context, token):
2057                self.end_rule(context, 'Scenario')
2058                self.end_rule(context, 'ScenarioDefinition')
2059                self.start_rule(context, 'ScenarioDefinition')
2060                self.start_rule(context, 'Scenario')
2061                self.build(context, token)
2062                return 31
2063        if self.match_RuleLine(context, token):
2064                self.end_rule(context, 'Scenario')
2065                self.end_rule(context, 'ScenarioDefinition')
2066                self.end_rule(context, 'Rule')
2067                self.start_rule(context, 'Rule')
2068                self.start_rule(context, 'RuleHeader')
2069                self.build(context, token)
2070                return 22
2071        if self.match_Empty(context, token):
2072                self.build(context, token)
2073                return 33
2074
2075        state_comment = "State: 33 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0"
2076        token.detach
2077        expected_tokens = ["#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"]
2078        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2079        if (self.stop_at_first_error):
2080            raise error
2081        self.add_error(context, error)
2082        return 33
2083
2084    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0
2085    def match_token_at_34(self, token, context):
2086        if self.match_EOF(context, token):
2087                self.end_rule(context, 'Step')
2088                self.end_rule(context, 'Scenario')
2089                self.end_rule(context, 'ScenarioDefinition')
2090                self.end_rule(context, 'Rule')
2091                self.end_rule(context, 'Feature')
2092                self.build(context, token)
2093                return 41
2094        if self.match_TableRow(context, token):
2095                self.start_rule(context, 'DataTable')
2096                self.build(context, token)
2097                return 35
2098        if self.match_DocStringSeparator(context, token):
2099                self.start_rule(context, 'DocString')
2100                self.build(context, token)
2101                return 42
2102        if self.match_StepLine(context, token):
2103                self.end_rule(context, 'Step')
2104                self.start_rule(context, 'Step')
2105                self.build(context, token)
2106                return 34
2107        if self.match_TagLine(context, token):
2108            if self.lookahead_0(context, token):
2109                self.end_rule(context, 'Step')
2110                self.start_rule(context, 'ExamplesDefinition')
2111                self.start_rule(context, 'Tags')
2112                self.build(context, token)
2113                return 36
2114        if self.match_TagLine(context, token):
2115                self.end_rule(context, 'Step')
2116                self.end_rule(context, 'Scenario')
2117                self.end_rule(context, 'ScenarioDefinition')
2118                self.start_rule(context, 'ScenarioDefinition')
2119                self.start_rule(context, 'Tags')
2120                self.build(context, token)
2121                return 30
2122        if self.match_ExamplesLine(context, token):
2123                self.end_rule(context, 'Step')
2124                self.start_rule(context, 'ExamplesDefinition')
2125                self.start_rule(context, 'Examples')
2126                self.build(context, token)
2127                return 37
2128        if self.match_ScenarioLine(context, token):
2129                self.end_rule(context, 'Step')
2130                self.end_rule(context, 'Scenario')
2131                self.end_rule(context, 'ScenarioDefinition')
2132                self.start_rule(context, 'ScenarioDefinition')
2133                self.start_rule(context, 'Scenario')
2134                self.build(context, token)
2135                return 31
2136        if self.match_RuleLine(context, token):
2137                self.end_rule(context, 'Step')
2138                self.end_rule(context, 'Scenario')
2139                self.end_rule(context, 'ScenarioDefinition')
2140                self.end_rule(context, 'Rule')
2141                self.start_rule(context, 'Rule')
2142                self.start_rule(context, 'RuleHeader')
2143                self.build(context, token)
2144                return 22
2145        if self.match_Comment(context, token):
2146                self.build(context, token)
2147                return 34
2148        if self.match_Empty(context, token):
2149                self.build(context, token)
2150                return 34
2151
2152        state_comment = "State: 34 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0"
2153        token.detach
2154        expected_tokens = ["#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
2155        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2156        if (self.stop_at_first_error):
2157            raise error
2158        self.add_error(context, error)
2159        return 34
2160
2161    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
2162    def match_token_at_35(self, token, context):
2163        if self.match_EOF(context, token):
2164                self.end_rule(context, 'DataTable')
2165                self.end_rule(context, 'Step')
2166                self.end_rule(context, 'Scenario')
2167                self.end_rule(context, 'ScenarioDefinition')
2168                self.end_rule(context, 'Rule')
2169                self.end_rule(context, 'Feature')
2170                self.build(context, token)
2171                return 41
2172        if self.match_TableRow(context, token):
2173                self.build(context, token)
2174                return 35
2175        if self.match_StepLine(context, token):
2176                self.end_rule(context, 'DataTable')
2177                self.end_rule(context, 'Step')
2178                self.start_rule(context, 'Step')
2179                self.build(context, token)
2180                return 34
2181        if self.match_TagLine(context, token):
2182            if self.lookahead_0(context, token):
2183                self.end_rule(context, 'DataTable')
2184                self.end_rule(context, 'Step')
2185                self.start_rule(context, 'ExamplesDefinition')
2186                self.start_rule(context, 'Tags')
2187                self.build(context, token)
2188                return 36
2189        if self.match_TagLine(context, token):
2190                self.end_rule(context, 'DataTable')
2191                self.end_rule(context, 'Step')
2192                self.end_rule(context, 'Scenario')
2193                self.end_rule(context, 'ScenarioDefinition')
2194                self.start_rule(context, 'ScenarioDefinition')
2195                self.start_rule(context, 'Tags')
2196                self.build(context, token)
2197                return 30
2198        if self.match_ExamplesLine(context, token):
2199                self.end_rule(context, 'DataTable')
2200                self.end_rule(context, 'Step')
2201                self.start_rule(context, 'ExamplesDefinition')
2202                self.start_rule(context, 'Examples')
2203                self.build(context, token)
2204                return 37
2205        if self.match_ScenarioLine(context, token):
2206                self.end_rule(context, 'DataTable')
2207                self.end_rule(context, 'Step')
2208                self.end_rule(context, 'Scenario')
2209                self.end_rule(context, 'ScenarioDefinition')
2210                self.start_rule(context, 'ScenarioDefinition')
2211                self.start_rule(context, 'Scenario')
2212                self.build(context, token)
2213                return 31
2214        if self.match_RuleLine(context, token):
2215                self.end_rule(context, 'DataTable')
2216                self.end_rule(context, 'Step')
2217                self.end_rule(context, 'Scenario')
2218                self.end_rule(context, 'ScenarioDefinition')
2219                self.end_rule(context, 'Rule')
2220                self.start_rule(context, 'Rule')
2221                self.start_rule(context, 'RuleHeader')
2222                self.build(context, token)
2223                return 22
2224        if self.match_Comment(context, token):
2225                self.build(context, token)
2226                return 35
2227        if self.match_Empty(context, token):
2228                self.build(context, token)
2229                return 35
2230
2231        state_comment = "State: 35 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0"
2232        token.detach
2233        expected_tokens = ["#EOF", "#TableRow", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
2234        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2235        if (self.stop_at_first_error):
2236            raise error
2237        self.add_error(context, error)
2238        return 35
2239
2240    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0
2241    def match_token_at_36(self, token, context):
2242        if self.match_TagLine(context, token):
2243                self.build(context, token)
2244                return 36
2245        if self.match_ExamplesLine(context, token):
2246                self.end_rule(context, 'Tags')
2247                self.start_rule(context, 'Examples')
2248                self.build(context, token)
2249                return 37
2250        if self.match_Comment(context, token):
2251                self.build(context, token)
2252                return 36
2253        if self.match_Empty(context, token):
2254                self.build(context, token)
2255                return 36
2256
2257        state_comment = "State: 36 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0"
2258        token.detach
2259        expected_tokens = ["#TagLine", "#ExamplesLine", "#Comment", "#Empty"]
2260        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2261        if (self.stop_at_first_error):
2262            raise error
2263        self.add_error(context, error)
2264        return 36
2265
2266    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0
2267    def match_token_at_37(self, token, context):
2268        if self.match_EOF(context, token):
2269                self.end_rule(context, 'Examples')
2270                self.end_rule(context, 'ExamplesDefinition')
2271                self.end_rule(context, 'Scenario')
2272                self.end_rule(context, 'ScenarioDefinition')
2273                self.end_rule(context, 'Rule')
2274                self.end_rule(context, 'Feature')
2275                self.build(context, token)
2276                return 41
2277        if self.match_Empty(context, token):
2278                self.build(context, token)
2279                return 37
2280        if self.match_Comment(context, token):
2281                self.build(context, token)
2282                return 39
2283        if self.match_TableRow(context, token):
2284                self.start_rule(context, 'ExamplesTable')
2285                self.build(context, token)
2286                return 40
2287        if self.match_TagLine(context, token):
2288            if self.lookahead_0(context, token):
2289                self.end_rule(context, 'Examples')
2290                self.end_rule(context, 'ExamplesDefinition')
2291                self.start_rule(context, 'ExamplesDefinition')
2292                self.start_rule(context, 'Tags')
2293                self.build(context, token)
2294                return 36
2295        if self.match_TagLine(context, token):
2296                self.end_rule(context, 'Examples')
2297                self.end_rule(context, 'ExamplesDefinition')
2298                self.end_rule(context, 'Scenario')
2299                self.end_rule(context, 'ScenarioDefinition')
2300                self.start_rule(context, 'ScenarioDefinition')
2301                self.start_rule(context, 'Tags')
2302                self.build(context, token)
2303                return 30
2304        if self.match_ExamplesLine(context, token):
2305                self.end_rule(context, 'Examples')
2306                self.end_rule(context, 'ExamplesDefinition')
2307                self.start_rule(context, 'ExamplesDefinition')
2308                self.start_rule(context, 'Examples')
2309                self.build(context, token)
2310                return 37
2311        if self.match_ScenarioLine(context, token):
2312                self.end_rule(context, 'Examples')
2313                self.end_rule(context, 'ExamplesDefinition')
2314                self.end_rule(context, 'Scenario')
2315                self.end_rule(context, 'ScenarioDefinition')
2316                self.start_rule(context, 'ScenarioDefinition')
2317                self.start_rule(context, 'Scenario')
2318                self.build(context, token)
2319                return 31
2320        if self.match_RuleLine(context, token):
2321                self.end_rule(context, 'Examples')
2322                self.end_rule(context, 'ExamplesDefinition')
2323                self.end_rule(context, 'Scenario')
2324                self.end_rule(context, 'ScenarioDefinition')
2325                self.end_rule(context, 'Rule')
2326                self.start_rule(context, 'Rule')
2327                self.start_rule(context, 'RuleHeader')
2328                self.build(context, token)
2329                return 22
2330        if self.match_Other(context, token):
2331                self.start_rule(context, 'Description')
2332                self.build(context, token)
2333                return 38
2334
2335        state_comment = "State: 37 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0"
2336        token.detach
2337        expected_tokens = ["#EOF", "#Empty", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
2338        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2339        if (self.stop_at_first_error):
2340            raise error
2341        self.add_error(context, error)
2342        return 37
2343
2344    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0
2345    def match_token_at_38(self, token, context):
2346        if self.match_EOF(context, token):
2347                self.end_rule(context, 'Description')
2348                self.end_rule(context, 'Examples')
2349                self.end_rule(context, 'ExamplesDefinition')
2350                self.end_rule(context, 'Scenario')
2351                self.end_rule(context, 'ScenarioDefinition')
2352                self.end_rule(context, 'Rule')
2353                self.end_rule(context, 'Feature')
2354                self.build(context, token)
2355                return 41
2356        if self.match_Comment(context, token):
2357                self.end_rule(context, 'Description')
2358                self.build(context, token)
2359                return 39
2360        if self.match_TableRow(context, token):
2361                self.end_rule(context, 'Description')
2362                self.start_rule(context, 'ExamplesTable')
2363                self.build(context, token)
2364                return 40
2365        if self.match_TagLine(context, token):
2366            if self.lookahead_0(context, token):
2367                self.end_rule(context, 'Description')
2368                self.end_rule(context, 'Examples')
2369                self.end_rule(context, 'ExamplesDefinition')
2370                self.start_rule(context, 'ExamplesDefinition')
2371                self.start_rule(context, 'Tags')
2372                self.build(context, token)
2373                return 36
2374        if self.match_TagLine(context, token):
2375                self.end_rule(context, 'Description')
2376                self.end_rule(context, 'Examples')
2377                self.end_rule(context, 'ExamplesDefinition')
2378                self.end_rule(context, 'Scenario')
2379                self.end_rule(context, 'ScenarioDefinition')
2380                self.start_rule(context, 'ScenarioDefinition')
2381                self.start_rule(context, 'Tags')
2382                self.build(context, token)
2383                return 30
2384        if self.match_ExamplesLine(context, token):
2385                self.end_rule(context, 'Description')
2386                self.end_rule(context, 'Examples')
2387                self.end_rule(context, 'ExamplesDefinition')
2388                self.start_rule(context, 'ExamplesDefinition')
2389                self.start_rule(context, 'Examples')
2390                self.build(context, token)
2391                return 37
2392        if self.match_ScenarioLine(context, token):
2393                self.end_rule(context, 'Description')
2394                self.end_rule(context, 'Examples')
2395                self.end_rule(context, 'ExamplesDefinition')
2396                self.end_rule(context, 'Scenario')
2397                self.end_rule(context, 'ScenarioDefinition')
2398                self.start_rule(context, 'ScenarioDefinition')
2399                self.start_rule(context, 'Scenario')
2400                self.build(context, token)
2401                return 31
2402        if self.match_RuleLine(context, token):
2403                self.end_rule(context, 'Description')
2404                self.end_rule(context, 'Examples')
2405                self.end_rule(context, 'ExamplesDefinition')
2406                self.end_rule(context, 'Scenario')
2407                self.end_rule(context, 'ScenarioDefinition')
2408                self.end_rule(context, 'Rule')
2409                self.start_rule(context, 'Rule')
2410                self.start_rule(context, 'RuleHeader')
2411                self.build(context, token)
2412                return 22
2413        if self.match_Other(context, token):
2414                self.build(context, token)
2415                return 38
2416
2417        state_comment = "State: 38 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0"
2418        token.detach
2419        expected_tokens = ["#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"]
2420        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2421        if (self.stop_at_first_error):
2422            raise error
2423        self.add_error(context, error)
2424        return 38
2425
2426    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0
2427    def match_token_at_39(self, token, context):
2428        if self.match_EOF(context, token):
2429                self.end_rule(context, 'Examples')
2430                self.end_rule(context, 'ExamplesDefinition')
2431                self.end_rule(context, 'Scenario')
2432                self.end_rule(context, 'ScenarioDefinition')
2433                self.end_rule(context, 'Rule')
2434                self.end_rule(context, 'Feature')
2435                self.build(context, token)
2436                return 41
2437        if self.match_Comment(context, token):
2438                self.build(context, token)
2439                return 39
2440        if self.match_TableRow(context, token):
2441                self.start_rule(context, 'ExamplesTable')
2442                self.build(context, token)
2443                return 40
2444        if self.match_TagLine(context, token):
2445            if self.lookahead_0(context, token):
2446                self.end_rule(context, 'Examples')
2447                self.end_rule(context, 'ExamplesDefinition')
2448                self.start_rule(context, 'ExamplesDefinition')
2449                self.start_rule(context, 'Tags')
2450                self.build(context, token)
2451                return 36
2452        if self.match_TagLine(context, token):
2453                self.end_rule(context, 'Examples')
2454                self.end_rule(context, 'ExamplesDefinition')
2455                self.end_rule(context, 'Scenario')
2456                self.end_rule(context, 'ScenarioDefinition')
2457                self.start_rule(context, 'ScenarioDefinition')
2458                self.start_rule(context, 'Tags')
2459                self.build(context, token)
2460                return 30
2461        if self.match_ExamplesLine(context, token):
2462                self.end_rule(context, 'Examples')
2463                self.end_rule(context, 'ExamplesDefinition')
2464                self.start_rule(context, 'ExamplesDefinition')
2465                self.start_rule(context, 'Examples')
2466                self.build(context, token)
2467                return 37
2468        if self.match_ScenarioLine(context, token):
2469                self.end_rule(context, 'Examples')
2470                self.end_rule(context, 'ExamplesDefinition')
2471                self.end_rule(context, 'Scenario')
2472                self.end_rule(context, 'ScenarioDefinition')
2473                self.start_rule(context, 'ScenarioDefinition')
2474                self.start_rule(context, 'Scenario')
2475                self.build(context, token)
2476                return 31
2477        if self.match_RuleLine(context, token):
2478                self.end_rule(context, 'Examples')
2479                self.end_rule(context, 'ExamplesDefinition')
2480                self.end_rule(context, 'Scenario')
2481                self.end_rule(context, 'ScenarioDefinition')
2482                self.end_rule(context, 'Rule')
2483                self.start_rule(context, 'Rule')
2484                self.start_rule(context, 'RuleHeader')
2485                self.build(context, token)
2486                return 22
2487        if self.match_Empty(context, token):
2488                self.build(context, token)
2489                return 39
2490
2491        state_comment = "State: 39 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0"
2492        token.detach
2493        expected_tokens = ["#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"]
2494        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2495        if (self.stop_at_first_error):
2496            raise error
2497        self.add_error(context, error)
2498        return 39
2499
2500    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0
2501    def match_token_at_40(self, token, context):
2502        if self.match_EOF(context, token):
2503                self.end_rule(context, 'ExamplesTable')
2504                self.end_rule(context, 'Examples')
2505                self.end_rule(context, 'ExamplesDefinition')
2506                self.end_rule(context, 'Scenario')
2507                self.end_rule(context, 'ScenarioDefinition')
2508                self.end_rule(context, 'Rule')
2509                self.end_rule(context, 'Feature')
2510                self.build(context, token)
2511                return 41
2512        if self.match_TableRow(context, token):
2513                self.build(context, token)
2514                return 40
2515        if self.match_TagLine(context, token):
2516            if self.lookahead_0(context, token):
2517                self.end_rule(context, 'ExamplesTable')
2518                self.end_rule(context, 'Examples')
2519                self.end_rule(context, 'ExamplesDefinition')
2520                self.start_rule(context, 'ExamplesDefinition')
2521                self.start_rule(context, 'Tags')
2522                self.build(context, token)
2523                return 36
2524        if self.match_TagLine(context, token):
2525                self.end_rule(context, 'ExamplesTable')
2526                self.end_rule(context, 'Examples')
2527                self.end_rule(context, 'ExamplesDefinition')
2528                self.end_rule(context, 'Scenario')
2529                self.end_rule(context, 'ScenarioDefinition')
2530                self.start_rule(context, 'ScenarioDefinition')
2531                self.start_rule(context, 'Tags')
2532                self.build(context, token)
2533                return 30
2534        if self.match_ExamplesLine(context, token):
2535                self.end_rule(context, 'ExamplesTable')
2536                self.end_rule(context, 'Examples')
2537                self.end_rule(context, 'ExamplesDefinition')
2538                self.start_rule(context, 'ExamplesDefinition')
2539                self.start_rule(context, 'Examples')
2540                self.build(context, token)
2541                return 37
2542        if self.match_ScenarioLine(context, token):
2543                self.end_rule(context, 'ExamplesTable')
2544                self.end_rule(context, 'Examples')
2545                self.end_rule(context, 'ExamplesDefinition')
2546                self.end_rule(context, 'Scenario')
2547                self.end_rule(context, 'ScenarioDefinition')
2548                self.start_rule(context, 'ScenarioDefinition')
2549                self.start_rule(context, 'Scenario')
2550                self.build(context, token)
2551                return 31
2552        if self.match_RuleLine(context, token):
2553                self.end_rule(context, 'ExamplesTable')
2554                self.end_rule(context, 'Examples')
2555                self.end_rule(context, 'ExamplesDefinition')
2556                self.end_rule(context, 'Scenario')
2557                self.end_rule(context, 'ScenarioDefinition')
2558                self.end_rule(context, 'Rule')
2559                self.start_rule(context, 'Rule')
2560                self.start_rule(context, 'RuleHeader')
2561                self.build(context, token)
2562                return 22
2563        if self.match_Comment(context, token):
2564                self.build(context, token)
2565                return 40
2566        if self.match_Empty(context, token):
2567                self.build(context, token)
2568                return 40
2569
2570        state_comment = "State: 40 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0"
2571        token.detach
2572        expected_tokens = ["#EOF", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
2573        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2574        if (self.stop_at_first_error):
2575            raise error
2576        self.add_error(context, error)
2577        return 40
2578
2579    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
2580    def match_token_at_42(self, token, context):
2581        if self.match_DocStringSeparator(context, token):
2582                self.build(context, token)
2583                return 43
2584        if self.match_Other(context, token):
2585                self.build(context, token)
2586                return 42
2587
2588        state_comment = "State: 42 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0"
2589        token.detach
2590        expected_tokens = ["#DocStringSeparator", "#Other"]
2591        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2592        if (self.stop_at_first_error):
2593            raise error
2594        self.add_error(context, error)
2595        return 42
2596
2597    # GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
2598    def match_token_at_43(self, token, context):
2599        if self.match_EOF(context, token):
2600                self.end_rule(context, 'DocString')
2601                self.end_rule(context, 'Step')
2602                self.end_rule(context, 'Scenario')
2603                self.end_rule(context, 'ScenarioDefinition')
2604                self.end_rule(context, 'Rule')
2605                self.end_rule(context, 'Feature')
2606                self.build(context, token)
2607                return 41
2608        if self.match_StepLine(context, token):
2609                self.end_rule(context, 'DocString')
2610                self.end_rule(context, 'Step')
2611                self.start_rule(context, 'Step')
2612                self.build(context, token)
2613                return 34
2614        if self.match_TagLine(context, token):
2615            if self.lookahead_0(context, token):
2616                self.end_rule(context, 'DocString')
2617                self.end_rule(context, 'Step')
2618                self.start_rule(context, 'ExamplesDefinition')
2619                self.start_rule(context, 'Tags')
2620                self.build(context, token)
2621                return 36
2622        if self.match_TagLine(context, token):
2623                self.end_rule(context, 'DocString')
2624                self.end_rule(context, 'Step')
2625                self.end_rule(context, 'Scenario')
2626                self.end_rule(context, 'ScenarioDefinition')
2627                self.start_rule(context, 'ScenarioDefinition')
2628                self.start_rule(context, 'Tags')
2629                self.build(context, token)
2630                return 30
2631        if self.match_ExamplesLine(context, token):
2632                self.end_rule(context, 'DocString')
2633                self.end_rule(context, 'Step')
2634                self.start_rule(context, 'ExamplesDefinition')
2635                self.start_rule(context, 'Examples')
2636                self.build(context, token)
2637                return 37
2638        if self.match_ScenarioLine(context, token):
2639                self.end_rule(context, 'DocString')
2640                self.end_rule(context, 'Step')
2641                self.end_rule(context, 'Scenario')
2642                self.end_rule(context, 'ScenarioDefinition')
2643                self.start_rule(context, 'ScenarioDefinition')
2644                self.start_rule(context, 'Scenario')
2645                self.build(context, token)
2646                return 31
2647        if self.match_RuleLine(context, token):
2648                self.end_rule(context, 'DocString')
2649                self.end_rule(context, 'Step')
2650                self.end_rule(context, 'Scenario')
2651                self.end_rule(context, 'ScenarioDefinition')
2652                self.end_rule(context, 'Rule')
2653                self.start_rule(context, 'Rule')
2654                self.start_rule(context, 'RuleHeader')
2655                self.build(context, token)
2656                return 22
2657        if self.match_Comment(context, token):
2658                self.build(context, token)
2659                return 43
2660        if self.match_Empty(context, token):
2661                self.build(context, token)
2662                return 43
2663
2664        state_comment = "State: 43 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0"
2665        token.detach
2666        expected_tokens = ["#EOF", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
2667        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2668        if (self.stop_at_first_error):
2669            raise error
2670        self.add_error(context, error)
2671        return 43
2672
2673    # GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
2674    def match_token_at_44(self, token, context):
2675        if self.match_DocStringSeparator(context, token):
2676                self.build(context, token)
2677                return 45
2678        if self.match_Other(context, token):
2679                self.build(context, token)
2680                return 44
2681
2682        state_comment = "State: 44 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0"
2683        token.detach
2684        expected_tokens = ["#DocStringSeparator", "#Other"]
2685        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2686        if (self.stop_at_first_error):
2687            raise error
2688        self.add_error(context, error)
2689        return 44
2690
2691    # GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
2692    def match_token_at_45(self, token, context):
2693        if self.match_EOF(context, token):
2694                self.end_rule(context, 'DocString')
2695                self.end_rule(context, 'Step')
2696                self.end_rule(context, 'Background')
2697                self.end_rule(context, 'Rule')
2698                self.end_rule(context, 'Feature')
2699                self.build(context, token)
2700                return 41
2701        if self.match_StepLine(context, token):
2702                self.end_rule(context, 'DocString')
2703                self.end_rule(context, 'Step')
2704                self.start_rule(context, 'Step')
2705                self.build(context, token)
2706                return 28
2707        if self.match_TagLine(context, token):
2708                self.end_rule(context, 'DocString')
2709                self.end_rule(context, 'Step')
2710                self.end_rule(context, 'Background')
2711                self.start_rule(context, 'ScenarioDefinition')
2712                self.start_rule(context, 'Tags')
2713                self.build(context, token)
2714                return 30
2715        if self.match_ScenarioLine(context, token):
2716                self.end_rule(context, 'DocString')
2717                self.end_rule(context, 'Step')
2718                self.end_rule(context, 'Background')
2719                self.start_rule(context, 'ScenarioDefinition')
2720                self.start_rule(context, 'Scenario')
2721                self.build(context, token)
2722                return 31
2723        if self.match_RuleLine(context, token):
2724                self.end_rule(context, 'DocString')
2725                self.end_rule(context, 'Step')
2726                self.end_rule(context, 'Background')
2727                self.end_rule(context, 'Rule')
2728                self.start_rule(context, 'Rule')
2729                self.start_rule(context, 'RuleHeader')
2730                self.build(context, token)
2731                return 22
2732        if self.match_Comment(context, token):
2733                self.build(context, token)
2734                return 45
2735        if self.match_Empty(context, token):
2736                self.build(context, token)
2737                return 45
2738
2739        state_comment = "State: 45 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0"
2740        token.detach
2741        expected_tokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
2742        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2743        if (self.stop_at_first_error):
2744            raise error
2745        self.add_error(context, error)
2746        return 45
2747
2748    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
2749    def match_token_at_46(self, token, context):
2750        if self.match_DocStringSeparator(context, token):
2751                self.build(context, token)
2752                return 47
2753        if self.match_Other(context, token):
2754                self.build(context, token)
2755                return 46
2756
2757        state_comment = "State: 46 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0"
2758        token.detach
2759        expected_tokens = ["#DocStringSeparator", "#Other"]
2760        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2761        if (self.stop_at_first_error):
2762            raise error
2763        self.add_error(context, error)
2764        return 46
2765
2766    # GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
2767    def match_token_at_47(self, token, context):
2768        if self.match_EOF(context, token):
2769                self.end_rule(context, 'DocString')
2770                self.end_rule(context, 'Step')
2771                self.end_rule(context, 'Scenario')
2772                self.end_rule(context, 'ScenarioDefinition')
2773                self.end_rule(context, 'Feature')
2774                self.build(context, token)
2775                return 41
2776        if self.match_StepLine(context, token):
2777                self.end_rule(context, 'DocString')
2778                self.end_rule(context, 'Step')
2779                self.start_rule(context, 'Step')
2780                self.build(context, token)
2781                return 15
2782        if self.match_TagLine(context, token):
2783            if self.lookahead_0(context, token):
2784                self.end_rule(context, 'DocString')
2785                self.end_rule(context, 'Step')
2786                self.start_rule(context, 'ExamplesDefinition')
2787                self.start_rule(context, 'Tags')
2788                self.build(context, token)
2789                return 17
2790        if self.match_TagLine(context, token):
2791                self.end_rule(context, 'DocString')
2792                self.end_rule(context, 'Step')
2793                self.end_rule(context, 'Scenario')
2794                self.end_rule(context, 'ScenarioDefinition')
2795                self.start_rule(context, 'ScenarioDefinition')
2796                self.start_rule(context, 'Tags')
2797                self.build(context, token)
2798                return 11
2799        if self.match_ExamplesLine(context, token):
2800                self.end_rule(context, 'DocString')
2801                self.end_rule(context, 'Step')
2802                self.start_rule(context, 'ExamplesDefinition')
2803                self.start_rule(context, 'Examples')
2804                self.build(context, token)
2805                return 18
2806        if self.match_ScenarioLine(context, token):
2807                self.end_rule(context, 'DocString')
2808                self.end_rule(context, 'Step')
2809                self.end_rule(context, 'Scenario')
2810                self.end_rule(context, 'ScenarioDefinition')
2811                self.start_rule(context, 'ScenarioDefinition')
2812                self.start_rule(context, 'Scenario')
2813                self.build(context, token)
2814                return 12
2815        if self.match_RuleLine(context, token):
2816                self.end_rule(context, 'DocString')
2817                self.end_rule(context, 'Step')
2818                self.end_rule(context, 'Scenario')
2819                self.end_rule(context, 'ScenarioDefinition')
2820                self.start_rule(context, 'Rule')
2821                self.start_rule(context, 'RuleHeader')
2822                self.build(context, token)
2823                return 22
2824        if self.match_Comment(context, token):
2825                self.build(context, token)
2826                return 47
2827        if self.match_Empty(context, token):
2828                self.build(context, token)
2829                return 47
2830
2831        state_comment = "State: 47 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0"
2832        token.detach
2833        expected_tokens = ["#EOF", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
2834        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2835        if (self.stop_at_first_error):
2836            raise error
2837        self.add_error(context, error)
2838        return 47
2839
2840    # GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
2841    def match_token_at_48(self, token, context):
2842        if self.match_DocStringSeparator(context, token):
2843                self.build(context, token)
2844                return 49
2845        if self.match_Other(context, token):
2846                self.build(context, token)
2847                return 48
2848
2849        state_comment = "State: 48 - GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0"
2850        token.detach
2851        expected_tokens = ["#DocStringSeparator", "#Other"]
2852        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2853        if (self.stop_at_first_error):
2854            raise error
2855        self.add_error(context, error)
2856        return 48
2857
2858    # GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
2859    def match_token_at_49(self, token, context):
2860        if self.match_EOF(context, token):
2861                self.end_rule(context, 'DocString')
2862                self.end_rule(context, 'Step')
2863                self.end_rule(context, 'Background')
2864                self.end_rule(context, 'Feature')
2865                self.build(context, token)
2866                return 41
2867        if self.match_StepLine(context, token):
2868                self.end_rule(context, 'DocString')
2869                self.end_rule(context, 'Step')
2870                self.start_rule(context, 'Step')
2871                self.build(context, token)
2872                return 9
2873        if self.match_TagLine(context, token):
2874                self.end_rule(context, 'DocString')
2875                self.end_rule(context, 'Step')
2876                self.end_rule(context, 'Background')
2877                self.start_rule(context, 'ScenarioDefinition')
2878                self.start_rule(context, 'Tags')
2879                self.build(context, token)
2880                return 11
2881        if self.match_ScenarioLine(context, token):
2882                self.end_rule(context, 'DocString')
2883                self.end_rule(context, 'Step')
2884                self.end_rule(context, 'Background')
2885                self.start_rule(context, 'ScenarioDefinition')
2886                self.start_rule(context, 'Scenario')
2887                self.build(context, token)
2888                return 12
2889        if self.match_RuleLine(context, token):
2890                self.end_rule(context, 'DocString')
2891                self.end_rule(context, 'Step')
2892                self.end_rule(context, 'Background')
2893                self.start_rule(context, 'Rule')
2894                self.start_rule(context, 'RuleHeader')
2895                self.build(context, token)
2896                return 22
2897        if self.match_Comment(context, token):
2898                self.build(context, token)
2899                return 49
2900        if self.match_Empty(context, token):
2901                self.build(context, token)
2902                return 49
2903
2904        state_comment = "State: 49 - GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0"
2905        token.detach
2906        expected_tokens = ["#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"]
2907        error = UnexpectedEOFException(token, expected_tokens, state_comment) if token.eof() else UnexpectedTokenException(token, expected_tokens, state_comment)
2908        if (self.stop_at_first_error):
2909            raise error
2910        self.add_error(context, error)
2911        return 49
2912
2913    def lookahead_0(self, context, currentToken):
2914        currentToken.detach
2915        token = None
2916        queue = []
2917        match = False
2918        while True:
2919            token = self.read_token(context)
2920            token.detach
2921            queue.append(token)
2922
2923            if (self.match_ExamplesLine(context, token) or False):
2924                match = True
2925                break
2926
2927            if not (self.match_Empty(context, token) or self.match_Comment(context, token) or self.match_TagLine(context, token) or False):
2928                break
2929
2930        context.token_queue.extend(queue)
2931
2932        return match
2933
2934    # private
2935
2936    def handle_ast_error(self, context, argument, action):
2937        self.handle_external_error(context, True, argument, action)
2938
2939    def handle_external_error(self, context, default_value, argument, action):
2940        if self.stop_at_first_error:
2941            return action(argument)
2942
2943        try:
2944            return action(argument)
2945        except CompositeParserException as e:
2946            for error in e.errors:
2947                self.add_error(context, error)
2948        except ParserException as e:
2949            self.add_error(context, e)
2950        return default_value
2951
Full Screen