localstack/services/stepfunctions/asl/antlr/runtime/ASLParser.py
# Generated from ASLParser.g4 by ANTLR 4.13.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
from typing import TextIO
else:
from typing.io import TextIO
def serializedATN():
return [
4,1,141,845,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
91,2,92,7,92,1,0,1,0,1,0,1,1,1,1,1,1,1,1,5,1,194,8,1,10,1,12,1,197,
9,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,3,2,206,8,2,1,3,1,3,1,3,1,3,1,4,
1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,
1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,
1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,255,8,6,1,7,1,7,1,7,
1,7,1,7,1,7,5,7,263,8,7,10,7,12,7,266,9,7,1,7,1,7,1,8,1,8,1,9,1,
9,1,9,1,9,1,10,1,10,1,10,1,10,5,10,280,8,10,10,10,12,10,283,9,10,
1,10,1,10,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13,1,13,1,13,
1,13,1,14,1,14,1,14,1,14,3,14,303,8,14,1,15,1,15,1,15,1,15,1,16,
1,16,1,16,1,16,3,16,313,8,16,1,17,1,17,1,17,1,17,3,17,319,8,17,1,
18,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1,21,1,
21,1,21,1,21,1,21,1,21,3,21,339,8,21,1,22,1,22,1,22,1,22,1,23,1,
23,1,23,1,23,1,23,1,23,3,23,351,8,23,1,24,1,24,1,24,1,24,1,25,1,
25,1,25,1,25,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,28,1,28,1,
28,1,28,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,
31,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,
35,1,35,1,35,1,35,1,36,1,36,1,36,1,36,5,36,405,8,36,10,36,12,36,
408,9,36,1,36,1,36,1,36,1,36,3,36,414,8,36,1,37,1,37,1,37,1,37,1,
37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,429,8,37,1,38,1,
38,1,39,1,39,1,39,1,39,5,39,437,8,39,10,39,12,39,440,9,39,1,39,1,
39,1,39,1,39,3,39,446,8,39,1,40,1,40,1,40,1,40,3,40,452,8,40,1,41,
1,41,1,41,1,41,1,41,3,41,459,8,41,1,42,1,42,1,42,1,42,1,43,1,43,
1,44,1,44,1,44,1,44,1,44,1,44,5,44,473,8,44,10,44,12,44,476,9,44,
1,44,1,44,1,45,1,45,1,45,1,45,4,45,484,8,45,11,45,12,45,485,1,45,
1,45,1,45,1,45,1,45,1,45,5,45,494,8,45,10,45,12,45,497,9,45,1,45,
1,45,3,45,501,8,45,1,46,1,46,1,46,1,46,3,46,507,8,46,1,47,1,47,3,
47,511,8,47,1,48,1,48,1,48,1,48,1,48,1,48,1,48,5,48,520,8,48,10,
48,12,48,523,9,48,1,48,1,48,3,48,527,8,48,1,49,1,49,1,49,1,49,1,
50,1,50,1,50,1,50,1,51,1,51,1,51,1,51,1,51,1,51,5,51,543,8,51,10,
51,12,51,546,9,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52,5,52,556,
8,52,10,52,12,52,559,9,52,1,52,1,52,1,53,1,53,1,53,1,53,3,53,567,
8,53,1,54,1,54,1,54,1,54,1,54,1,54,5,54,575,8,54,10,54,12,54,578,
9,54,1,54,1,54,1,55,1,55,3,55,584,8,55,1,56,1,56,1,56,1,56,1,57,
1,57,1,58,1,58,1,58,1,58,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,60,
5,60,604,8,60,10,60,12,60,607,9,60,1,60,1,60,1,61,1,61,1,61,1,61,
3,61,615,8,61,1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,
5,63,627,8,63,10,63,12,63,630,9,63,1,63,1,63,1,64,1,64,1,64,3,64,
637,8,64,1,65,1,65,1,65,1,65,1,65,1,65,5,65,645,8,65,10,65,12,65,
648,9,65,1,65,1,65,1,66,1,66,1,66,1,66,1,66,3,66,657,8,66,1,67,1,
67,1,67,1,67,1,68,1,68,1,68,1,68,1,69,1,69,1,69,1,69,1,69,1,69,5,
69,673,8,69,10,69,12,69,676,9,69,1,69,1,69,1,70,1,70,1,70,1,70,1,
71,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72,1,72,5,72,694,8,72,10,
72,12,72,697,9,72,3,72,699,8,72,1,72,1,72,1,73,1,73,1,73,1,73,5,
73,707,8,73,10,73,12,73,710,9,73,1,73,1,73,1,74,1,74,1,74,1,74,1,
74,1,74,1,74,3,74,721,8,74,1,75,1,75,1,75,1,75,1,75,1,75,5,75,729,
8,75,10,75,12,75,732,9,75,1,75,1,75,1,76,1,76,1,76,1,76,1,77,1,77,
1,77,1,77,1,78,1,78,1,78,1,78,1,79,1,79,1,79,1,79,1,80,1,80,1,80,
1,80,1,81,1,81,1,81,1,81,1,81,1,81,5,81,762,8,81,10,81,12,81,765,
9,81,3,81,767,8,81,1,81,1,81,1,82,1,82,1,82,1,82,5,82,775,8,82,10,
82,12,82,778,9,82,1,82,1,82,1,83,1,83,1,83,1,83,3,83,786,8,83,1,
84,1,84,1,85,1,85,1,86,1,86,1,87,1,87,3,87,796,8,87,1,88,1,88,1,
88,1,88,5,88,802,8,88,10,88,12,88,805,9,88,1,88,1,88,1,88,1,88,3,
88,811,8,88,1,89,1,89,1,89,1,89,1,90,1,90,1,90,1,90,5,90,821,8,90,
10,90,12,90,824,9,90,1,90,1,90,1,90,1,90,3,90,830,8,90,1,91,1,91,
1,91,1,91,1,91,1,91,1,91,1,91,1,91,3,91,841,8,91,1,92,1,92,1,92,
0,0,93,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,
42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,
86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,
122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,
154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,
0,9,1,0,7,8,1,0,16,23,1,0,80,81,1,0,139,140,1,0,117,118,3,0,29,36,
38,47,49,69,3,0,28,28,37,37,48,48,1,0,120,134,5,0,10,13,15,106,108,
108,110,120,122,138,870,0,186,1,0,0,0,2,189,1,0,0,0,4,205,1,0,0,
0,6,207,1,0,0,0,8,211,1,0,0,0,10,215,1,0,0,0,12,254,1,0,0,0,14,256,
1,0,0,0,16,269,1,0,0,0,18,271,1,0,0,0,20,275,1,0,0,0,22,286,1,0,
0,0,24,290,1,0,0,0,26,294,1,0,0,0,28,298,1,0,0,0,30,304,1,0,0,0,
32,308,1,0,0,0,34,314,1,0,0,0,36,320,1,0,0,0,38,324,1,0,0,0,40,328,
1,0,0,0,42,338,1,0,0,0,44,340,1,0,0,0,46,350,1,0,0,0,48,352,1,0,
0,0,50,356,1,0,0,0,52,360,1,0,0,0,54,364,1,0,0,0,56,368,1,0,0,0,
58,372,1,0,0,0,60,376,1,0,0,0,62,380,1,0,0,0,64,384,1,0,0,0,66,388,
1,0,0,0,68,392,1,0,0,0,70,396,1,0,0,0,72,413,1,0,0,0,74,428,1,0,
0,0,76,430,1,0,0,0,78,445,1,0,0,0,80,451,1,0,0,0,82,458,1,0,0,0,
84,460,1,0,0,0,86,464,1,0,0,0,88,466,1,0,0,0,90,500,1,0,0,0,92,506,
1,0,0,0,94,510,1,0,0,0,96,512,1,0,0,0,98,528,1,0,0,0,100,532,1,0,
0,0,102,536,1,0,0,0,104,549,1,0,0,0,106,566,1,0,0,0,108,568,1,0,
0,0,110,583,1,0,0,0,112,585,1,0,0,0,114,589,1,0,0,0,116,591,1,0,
0,0,118,595,1,0,0,0,120,597,1,0,0,0,122,614,1,0,0,0,124,616,1,0,
0,0,126,620,1,0,0,0,128,636,1,0,0,0,130,638,1,0,0,0,132,656,1,0,
0,0,134,658,1,0,0,0,136,662,1,0,0,0,138,666,1,0,0,0,140,679,1,0,
0,0,142,683,1,0,0,0,144,687,1,0,0,0,146,702,1,0,0,0,148,720,1,0,
0,0,150,722,1,0,0,0,152,735,1,0,0,0,154,739,1,0,0,0,156,743,1,0,
0,0,158,747,1,0,0,0,160,751,1,0,0,0,162,755,1,0,0,0,164,770,1,0,
0,0,166,785,1,0,0,0,168,787,1,0,0,0,170,789,1,0,0,0,172,791,1,0,
0,0,174,795,1,0,0,0,176,810,1,0,0,0,178,812,1,0,0,0,180,829,1,0,
0,0,182,840,1,0,0,0,184,842,1,0,0,0,186,187,3,2,1,0,187,188,5,0,
0,1,188,1,1,0,0,0,189,190,5,5,0,0,190,195,3,4,2,0,191,192,5,1,0,
0,192,194,3,4,2,0,193,191,1,0,0,0,194,197,1,0,0,0,195,193,1,0,0,
0,195,196,1,0,0,0,196,198,1,0,0,0,197,195,1,0,0,0,198,199,5,6,0,
0,199,3,1,0,0,0,200,206,3,8,4,0,201,206,3,10,5,0,202,206,3,6,3,0,
203,206,3,14,7,0,204,206,3,64,32,0,205,200,1,0,0,0,205,201,1,0,0,
0,205,202,1,0,0,0,205,203,1,0,0,0,205,204,1,0,0,0,206,5,1,0,0,0,
207,208,5,12,0,0,208,209,5,2,0,0,209,210,3,184,92,0,210,7,1,0,0,
0,211,212,5,10,0,0,212,213,5,2,0,0,213,214,3,184,92,0,214,9,1,0,
0,0,215,216,5,14,0,0,216,217,5,2,0,0,217,218,3,184,92,0,218,11,1,
0,0,0,219,255,3,8,4,0,220,255,3,22,11,0,221,255,3,28,14,0,222,255,
3,26,13,0,223,255,3,24,12,0,224,255,3,30,15,0,225,255,3,32,16,0,
226,255,3,34,17,0,227,255,3,36,18,0,228,255,3,38,19,0,229,255,3,
88,44,0,230,255,3,40,20,0,231,255,3,42,21,0,232,255,3,44,22,0,233,
255,3,46,23,0,234,255,3,48,24,0,235,255,3,50,25,0,236,255,3,52,26,
0,237,255,3,54,27,0,238,255,3,56,28,0,239,255,3,104,52,0,240,255,
3,120,60,0,241,255,3,124,62,0,242,255,3,126,63,0,243,255,3,58,29,
0,244,255,3,60,30,0,245,255,3,64,32,0,246,255,3,66,33,0,247,255,
3,68,34,0,248,255,3,70,35,0,249,255,3,102,51,0,250,255,3,62,31,0,
251,255,3,144,72,0,252,255,3,162,81,0,253,255,3,84,42,0,254,219,
1,0,0,0,254,220,1,0,0,0,254,221,1,0,0,0,254,222,1,0,0,0,254,223,
1,0,0,0,254,224,1,0,0,0,254,225,1,0,0,0,254,226,1,0,0,0,254,227,
1,0,0,0,254,228,1,0,0,0,254,229,1,0,0,0,254,230,1,0,0,0,254,231,
1,0,0,0,254,232,1,0,0,0,254,233,1,0,0,0,254,234,1,0,0,0,254,235,
1,0,0,0,254,236,1,0,0,0,254,237,1,0,0,0,254,238,1,0,0,0,254,239,
1,0,0,0,254,240,1,0,0,0,254,241,1,0,0,0,254,242,1,0,0,0,254,243,
1,0,0,0,254,244,1,0,0,0,254,245,1,0,0,0,254,246,1,0,0,0,254,247,
1,0,0,0,254,248,1,0,0,0,254,249,1,0,0,0,254,250,1,0,0,0,254,251,
1,0,0,0,254,252,1,0,0,0,254,253,1,0,0,0,255,13,1,0,0,0,256,257,5,
11,0,0,257,258,5,2,0,0,258,259,5,5,0,0,259,264,3,18,9,0,260,261,
5,1,0,0,261,263,3,18,9,0,262,260,1,0,0,0,263,266,1,0,0,0,264,262,
1,0,0,0,264,265,1,0,0,0,265,267,1,0,0,0,266,264,1,0,0,0,267,268,
5,6,0,0,268,15,1,0,0,0,269,270,3,184,92,0,270,17,1,0,0,0,271,272,
3,16,8,0,272,273,5,2,0,0,273,274,3,20,10,0,274,19,1,0,0,0,275,276,
5,5,0,0,276,281,3,12,6,0,277,278,5,1,0,0,278,280,3,12,6,0,279,277,
1,0,0,0,280,283,1,0,0,0,281,279,1,0,0,0,281,282,1,0,0,0,282,284,
1,0,0,0,283,281,1,0,0,0,284,285,5,6,0,0,285,21,1,0,0,0,286,287,5,
15,0,0,287,288,5,2,0,0,288,289,3,86,43,0,289,23,1,0,0,0,290,291,
5,104,0,0,291,292,5,2,0,0,292,293,3,184,92,0,293,25,1,0,0,0,294,
295,5,89,0,0,295,296,5,2,0,0,296,297,3,184,92,0,297,27,1,0,0,0,298,
299,5,90,0,0,299,302,5,2,0,0,300,303,5,9,0,0,301,303,3,184,92,0,
302,300,1,0,0,0,302,301,1,0,0,0,303,29,1,0,0,0,304,305,5,94,0,0,
305,306,5,2,0,0,306,307,3,182,91,0,307,31,1,0,0,0,308,309,5,93,0,
0,309,312,5,2,0,0,310,313,5,9,0,0,311,313,3,184,92,0,312,310,1,0,
0,0,312,311,1,0,0,0,313,33,1,0,0,0,314,315,5,91,0,0,315,318,5,2,
0,0,316,319,5,9,0,0,317,319,3,184,92,0,318,316,1,0,0,0,318,317,1,
0,0,0,319,35,1,0,0,0,320,321,5,105,0,0,321,322,5,2,0,0,322,323,7,
0,0,0,323,37,1,0,0,0,324,325,5,26,0,0,325,326,5,2,0,0,326,327,3,
184,92,0,327,39,1,0,0,0,328,329,5,108,0,0,329,330,5,2,0,0,330,331,
3,184,92,0,331,41,1,0,0,0,332,333,5,109,0,0,333,334,5,2,0,0,334,
339,5,137,0,0,335,336,5,109,0,0,336,337,5,2,0,0,337,339,3,76,38,
0,338,332,1,0,0,0,338,335,1,0,0,0,339,43,1,0,0,0,340,341,5,106,0,
0,341,342,5,2,0,0,342,343,3,184,92,0,343,45,1,0,0,0,344,345,5,107,
0,0,345,346,5,2,0,0,346,351,5,137,0,0,347,348,5,107,0,0,348,349,
5,2,0,0,349,351,3,76,38,0,350,344,1,0,0,0,350,347,1,0,0,0,351,47,
1,0,0,0,352,353,5,71,0,0,353,354,5,2,0,0,354,355,5,139,0,0,355,49,
1,0,0,0,356,357,5,70,0,0,357,358,5,2,0,0,358,359,3,184,92,0,359,
51,1,0,0,0,360,361,5,73,0,0,361,362,5,2,0,0,362,363,3,184,92,0,363,
53,1,0,0,0,364,365,5,72,0,0,365,366,5,2,0,0,366,367,3,184,92,0,367,
55,1,0,0,0,368,369,5,92,0,0,369,370,5,2,0,0,370,371,3,184,92,0,371,
57,1,0,0,0,372,373,5,88,0,0,373,374,5,2,0,0,374,375,5,139,0,0,375,
59,1,0,0,0,376,377,5,87,0,0,377,378,5,2,0,0,378,379,5,137,0,0,379,
61,1,0,0,0,380,381,5,95,0,0,381,382,5,2,0,0,382,383,3,72,36,0,383,
63,1,0,0,0,384,385,5,74,0,0,385,386,5,2,0,0,386,387,5,139,0,0,387,
65,1,0,0,0,388,389,5,75,0,0,389,390,5,2,0,0,390,391,5,137,0,0,391,
67,1,0,0,0,392,393,5,76,0,0,393,394,5,2,0,0,394,395,5,139,0,0,395,
69,1,0,0,0,396,397,5,77,0,0,397,398,5,2,0,0,398,399,5,137,0,0,399,
71,1,0,0,0,400,401,5,5,0,0,401,406,3,74,37,0,402,403,5,1,0,0,403,
405,3,74,37,0,404,402,1,0,0,0,405,408,1,0,0,0,406,404,1,0,0,0,406,
407,1,0,0,0,407,409,1,0,0,0,408,406,1,0,0,0,409,410,5,6,0,0,410,
414,1,0,0,0,411,412,5,5,0,0,412,414,5,6,0,0,413,400,1,0,0,0,413,
411,1,0,0,0,414,73,1,0,0,0,415,416,5,135,0,0,416,417,5,2,0,0,417,
429,5,137,0,0,418,419,5,135,0,0,419,420,5,2,0,0,420,429,5,136,0,
0,421,422,5,135,0,0,422,423,5,2,0,0,423,429,3,76,38,0,424,425,3,
184,92,0,425,426,5,2,0,0,426,427,3,80,40,0,427,429,1,0,0,0,428,415,
1,0,0,0,428,418,1,0,0,0,428,421,1,0,0,0,428,424,1,0,0,0,429,75,1,
0,0,0,430,431,5,138,0,0,431,77,1,0,0,0,432,433,5,3,0,0,433,438,3,
80,40,0,434,435,5,1,0,0,435,437,3,80,40,0,436,434,1,0,0,0,437,440,
1,0,0,0,438,436,1,0,0,0,438,439,1,0,0,0,439,441,1,0,0,0,440,438,
1,0,0,0,441,442,5,4,0,0,442,446,1,0,0,0,443,444,5,3,0,0,444,446,
5,4,0,0,445,432,1,0,0,0,445,443,1,0,0,0,446,79,1,0,0,0,447,452,3,
74,37,0,448,452,3,78,39,0,449,452,3,72,36,0,450,452,3,82,41,0,451,
447,1,0,0,0,451,448,1,0,0,0,451,449,1,0,0,0,451,450,1,0,0,0,452,
81,1,0,0,0,453,459,5,140,0,0,454,459,5,139,0,0,455,459,7,0,0,0,456,
459,5,9,0,0,457,459,3,184,92,0,458,453,1,0,0,0,458,454,1,0,0,0,458,
455,1,0,0,0,458,456,1,0,0,0,458,457,1,0,0,0,459,83,1,0,0,0,460,461,
5,96,0,0,461,462,5,2,0,0,462,463,3,72,36,0,463,85,1,0,0,0,464,465,
7,1,0,0,465,87,1,0,0,0,466,467,5,24,0,0,467,468,5,2,0,0,468,469,
5,3,0,0,469,474,3,90,45,0,470,471,5,1,0,0,471,473,3,90,45,0,472,
470,1,0,0,0,473,476,1,0,0,0,474,472,1,0,0,0,474,475,1,0,0,0,475,
477,1,0,0,0,476,474,1,0,0,0,477,478,5,4,0,0,478,89,1,0,0,0,479,480,
5,5,0,0,480,483,3,92,46,0,481,482,5,1,0,0,482,484,3,92,46,0,483,
481,1,0,0,0,484,485,1,0,0,0,485,483,1,0,0,0,485,486,1,0,0,0,486,
487,1,0,0,0,487,488,5,6,0,0,488,501,1,0,0,0,489,490,5,5,0,0,490,
495,3,94,47,0,491,492,5,1,0,0,492,494,3,94,47,0,493,491,1,0,0,0,
494,497,1,0,0,0,495,493,1,0,0,0,495,496,1,0,0,0,496,498,1,0,0,0,
497,495,1,0,0,0,498,499,5,6,0,0,499,501,1,0,0,0,500,479,1,0,0,0,
500,489,1,0,0,0,501,91,1,0,0,0,502,507,3,98,49,0,503,507,3,100,50,
0,504,507,3,24,12,0,505,507,3,8,4,0,506,502,1,0,0,0,506,503,1,0,
0,0,506,504,1,0,0,0,506,505,1,0,0,0,507,93,1,0,0,0,508,511,3,96,
48,0,509,511,3,24,12,0,510,508,1,0,0,0,510,509,1,0,0,0,511,95,1,
0,0,0,512,513,3,170,85,0,513,526,5,2,0,0,514,527,3,90,45,0,515,516,
5,3,0,0,516,521,3,90,45,0,517,518,5,1,0,0,518,520,3,90,45,0,519,
517,1,0,0,0,520,523,1,0,0,0,521,519,1,0,0,0,521,522,1,0,0,0,522,
524,1,0,0,0,523,521,1,0,0,0,524,525,5,4,0,0,525,527,1,0,0,0,526,
514,1,0,0,0,526,515,1,0,0,0,527,97,1,0,0,0,528,529,5,25,0,0,529,
530,5,2,0,0,530,531,3,184,92,0,531,99,1,0,0,0,532,533,3,168,84,0,
533,534,5,2,0,0,534,535,3,182,91,0,535,101,1,0,0,0,536,537,5,27,
0,0,537,538,5,2,0,0,538,539,5,3,0,0,539,544,3,2,1,0,540,541,5,1,
0,0,541,543,3,2,1,0,542,540,1,0,0,0,543,546,1,0,0,0,544,542,1,0,
0,0,544,545,1,0,0,0,545,547,1,0,0,0,546,544,1,0,0,0,547,548,5,4,
0,0,548,103,1,0,0,0,549,550,5,84,0,0,550,551,5,2,0,0,551,552,5,5,
0,0,552,557,3,106,53,0,553,554,5,1,0,0,554,556,3,106,53,0,555,553,
1,0,0,0,556,559,1,0,0,0,557,555,1,0,0,0,557,558,1,0,0,0,558,560,
1,0,0,0,559,557,1,0,0,0,560,561,5,6,0,0,561,105,1,0,0,0,562,567,
3,108,54,0,563,567,3,6,3,0,564,567,3,14,7,0,565,567,3,8,4,0,566,
562,1,0,0,0,566,563,1,0,0,0,566,564,1,0,0,0,566,565,1,0,0,0,567,
107,1,0,0,0,568,569,5,78,0,0,569,570,5,2,0,0,570,571,5,5,0,0,571,
576,3,110,55,0,572,573,5,1,0,0,573,575,3,110,55,0,574,572,1,0,0,
0,575,578,1,0,0,0,576,574,1,0,0,0,576,577,1,0,0,0,577,579,1,0,0,
0,578,576,1,0,0,0,579,580,5,6,0,0,580,109,1,0,0,0,581,584,3,112,
56,0,582,584,3,116,58,0,583,581,1,0,0,0,583,582,1,0,0,0,584,111,
1,0,0,0,585,586,5,79,0,0,586,587,5,2,0,0,587,588,3,114,57,0,588,
113,1,0,0,0,589,590,7,2,0,0,590,115,1,0,0,0,591,592,5,82,0,0,592,
593,5,2,0,0,593,594,3,118,59,0,594,117,1,0,0,0,595,596,5,83,0,0,
596,119,1,0,0,0,597,598,5,85,0,0,598,599,5,2,0,0,599,600,5,5,0,0,
600,605,3,122,61,0,601,602,5,1,0,0,602,604,3,122,61,0,603,601,1,
0,0,0,604,607,1,0,0,0,605,603,1,0,0,0,605,606,1,0,0,0,606,608,1,
0,0,0,607,605,1,0,0,0,608,609,5,6,0,0,609,121,1,0,0,0,610,615,3,
6,3,0,611,615,3,14,7,0,612,615,3,8,4,0,613,615,3,108,54,0,614,610,
1,0,0,0,614,611,1,0,0,0,614,612,1,0,0,0,614,613,1,0,0,0,615,123,
1,0,0,0,616,617,5,86,0,0,617,618,5,2,0,0,618,619,3,72,36,0,619,125,
1,0,0,0,620,621,5,97,0,0,621,622,5,2,0,0,622,623,5,5,0,0,623,628,
3,128,64,0,624,625,5,1,0,0,625,627,3,128,64,0,626,624,1,0,0,0,627,
630,1,0,0,0,628,626,1,0,0,0,628,629,1,0,0,0,629,631,1,0,0,0,630,
628,1,0,0,0,631,632,5,6,0,0,632,127,1,0,0,0,633,637,3,26,13,0,634,
637,3,62,31,0,635,637,3,130,65,0,636,633,1,0,0,0,636,634,1,0,0,0,
636,635,1,0,0,0,637,129,1,0,0,0,638,639,5,98,0,0,639,640,5,2,0,0,
640,641,5,5,0,0,641,646,3,132,66,0,642,643,5,1,0,0,643,645,3,132,
66,0,644,642,1,0,0,0,645,648,1,0,0,0,646,644,1,0,0,0,646,647,1,0,
0,0,647,649,1,0,0,0,648,646,1,0,0,0,649,650,5,6,0,0,650,131,1,0,
0,0,651,657,3,134,67,0,652,657,3,136,68,0,653,657,3,138,69,0,654,
657,3,140,70,0,655,657,3,142,71,0,656,651,1,0,0,0,656,652,1,0,0,
0,656,653,1,0,0,0,656,654,1,0,0,0,656,655,1,0,0,0,657,133,1,0,0,
0,658,659,5,99,0,0,659,660,5,2,0,0,660,661,3,184,92,0,661,135,1,
0,0,0,662,663,5,100,0,0,663,664,5,2,0,0,664,665,3,184,92,0,665,137,
1,0,0,0,666,667,5,101,0,0,667,668,5,2,0,0,668,669,5,3,0,0,669,674,
3,184,92,0,670,671,5,1,0,0,671,673,3,184,92,0,672,670,1,0,0,0,673,
676,1,0,0,0,674,672,1,0,0,0,674,675,1,0,0,0,675,677,1,0,0,0,676,
674,1,0,0,0,677,678,5,4,0,0,678,139,1,0,0,0,679,680,5,102,0,0,680,
681,5,2,0,0,681,682,5,139,0,0,682,141,1,0,0,0,683,684,5,103,0,0,
684,685,5,2,0,0,685,686,5,137,0,0,686,143,1,0,0,0,687,688,5,110,
0,0,688,689,5,2,0,0,689,698,5,3,0,0,690,695,3,146,73,0,691,692,5,
1,0,0,692,694,3,146,73,0,693,691,1,0,0,0,694,697,1,0,0,0,695,693,
1,0,0,0,695,696,1,0,0,0,696,699,1,0,0,0,697,695,1,0,0,0,698,690,
1,0,0,0,698,699,1,0,0,0,699,700,1,0,0,0,700,701,5,4,0,0,701,145,
1,0,0,0,702,703,5,5,0,0,703,708,3,148,74,0,704,705,5,1,0,0,705,707,
3,148,74,0,706,704,1,0,0,0,707,710,1,0,0,0,708,706,1,0,0,0,708,709,
1,0,0,0,709,711,1,0,0,0,710,708,1,0,0,0,711,712,5,6,0,0,712,147,
1,0,0,0,713,721,3,150,75,0,714,721,3,152,76,0,715,721,3,154,77,0,
716,721,3,156,78,0,717,721,3,158,79,0,718,721,3,160,80,0,719,721,
3,8,4,0,720,713,1,0,0,0,720,714,1,0,0,0,720,715,1,0,0,0,720,716,
1,0,0,0,720,717,1,0,0,0,720,718,1,0,0,0,720,719,1,0,0,0,721,149,
1,0,0,0,722,723,5,111,0,0,723,724,5,2,0,0,724,725,5,3,0,0,725,730,
3,174,87,0,726,727,5,1,0,0,727,729,3,174,87,0,728,726,1,0,0,0,729,
732,1,0,0,0,730,728,1,0,0,0,730,731,1,0,0,0,731,733,1,0,0,0,732,
730,1,0,0,0,733,734,5,4,0,0,734,151,1,0,0,0,735,736,5,112,0,0,736,
737,5,2,0,0,737,738,5,139,0,0,738,153,1,0,0,0,739,740,5,113,0,0,
740,741,5,2,0,0,741,742,5,139,0,0,742,155,1,0,0,0,743,744,5,114,
0,0,744,745,5,2,0,0,745,746,7,3,0,0,746,157,1,0,0,0,747,748,5,115,
0,0,748,749,5,2,0,0,749,750,5,139,0,0,750,159,1,0,0,0,751,752,5,
116,0,0,752,753,5,2,0,0,753,754,7,4,0,0,754,161,1,0,0,0,755,756,
5,119,0,0,756,757,5,2,0,0,757,766,5,3,0,0,758,763,3,164,82,0,759,
760,5,1,0,0,760,762,3,164,82,0,761,759,1,0,0,0,762,765,1,0,0,0,763,
761,1,0,0,0,763,764,1,0,0,0,764,767,1,0,0,0,765,763,1,0,0,0,766,
758,1,0,0,0,766,767,1,0,0,0,767,768,1,0,0,0,768,769,5,4,0,0,769,
163,1,0,0,0,770,771,5,5,0,0,771,776,3,166,83,0,772,773,5,1,0,0,773,
775,3,166,83,0,774,772,1,0,0,0,775,778,1,0,0,0,776,774,1,0,0,0,776,
777,1,0,0,0,777,779,1,0,0,0,778,776,1,0,0,0,779,780,5,6,0,0,780,
165,1,0,0,0,781,786,3,150,75,0,782,786,3,32,16,0,783,786,3,24,12,
0,784,786,3,8,4,0,785,781,1,0,0,0,785,782,1,0,0,0,785,783,1,0,0,
0,785,784,1,0,0,0,786,167,1,0,0,0,787,788,7,5,0,0,788,169,1,0,0,
0,789,790,7,6,0,0,790,171,1,0,0,0,791,792,7,7,0,0,792,173,1,0,0,
0,793,796,3,172,86,0,794,796,3,184,92,0,795,793,1,0,0,0,795,794,
1,0,0,0,796,175,1,0,0,0,797,798,5,5,0,0,798,803,3,178,89,0,799,800,
5,1,0,0,800,802,3,178,89,0,801,799,1,0,0,0,802,805,1,0,0,0,803,801,
1,0,0,0,803,804,1,0,0,0,804,806,1,0,0,0,805,803,1,0,0,0,806,807,
5,6,0,0,807,811,1,0,0,0,808,809,5,5,0,0,809,811,5,6,0,0,810,797,
1,0,0,0,810,808,1,0,0,0,811,177,1,0,0,0,812,813,3,184,92,0,813,814,
5,2,0,0,814,815,3,182,91,0,815,179,1,0,0,0,816,817,5,3,0,0,817,822,
3,182,91,0,818,819,5,1,0,0,819,821,3,182,91,0,820,818,1,0,0,0,821,
824,1,0,0,0,822,820,1,0,0,0,822,823,1,0,0,0,823,825,1,0,0,0,824,
822,1,0,0,0,825,826,5,4,0,0,826,830,1,0,0,0,827,828,5,3,0,0,828,
830,5,4,0,0,829,816,1,0,0,0,829,827,1,0,0,0,830,181,1,0,0,0,831,
841,5,140,0,0,832,841,5,139,0,0,833,841,5,7,0,0,834,841,5,8,0,0,
835,841,5,9,0,0,836,841,3,178,89,0,837,841,3,180,90,0,838,841,3,
176,88,0,839,841,3,184,92,0,840,831,1,0,0,0,840,832,1,0,0,0,840,
833,1,0,0,0,840,834,1,0,0,0,840,835,1,0,0,0,840,836,1,0,0,0,840,
837,1,0,0,0,840,838,1,0,0,0,840,839,1,0,0,0,841,183,1,0,0,0,842,
843,7,8,0,0,843,185,1,0,0,0,52,195,205,254,264,281,302,312,318,338,
350,406,413,428,438,445,451,458,474,485,495,500,506,510,521,526,
544,557,566,576,583,605,614,628,636,646,656,674,695,698,708,720,
730,763,766,776,785,795,803,810,822,829,840
]
class ASLParser ( Parser ):
grammarFileName = "ASLParser.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
sharedContextCache = PredictionContextCache()
literalNames = [ "<INVALID>", "','", "':'", "'['", "']'", "'{'", "'}'",
"'true'", "'false'", "'null'", "'\"Comment\"'", "'\"States\"'",
"'\"StartAt\"'", "'\"NextState\"'", "'\"Version\"'",
"'\"Type\"'", "'\"Task\"'", "'\"Choice\"'", "'\"Fail\"'",
"'\"Succeed\"'", "'\"Pass\"'", "'\"Wait\"'", "'\"Parallel\"'",
"'\"Map\"'", "'\"Choices\"'", "'\"Variable\"'", "'\"Default\"'",
"'\"Branches\"'", "'\"And\"'", "'\"BooleanEquals\"'",
"'\"BooleanEqualsPath\"'", "'\"IsBoolean\"'", "'\"IsNull\"'",
"'\"IsNumeric\"'", "'\"IsPresent\"'", "'\"IsString\"'",
"'\"IsTimestamp\"'", "'\"Not\"'", "'\"NumericEquals\"'",
"'\"NumericEqualsPath\"'", "'\"NumericGreaterThan\"'",
"'\"NumericGreaterThanPath\"'", "'\"NumericGreaterThanEquals\"'",
"'\"NumericGreaterThanEqualsPath\"'", "'\"NumericLessThan\"'",
"'\"NumericLessThanPath\"'", "'\"NumericLessThanEquals\"'",
"'\"NumericLessThanEqualsPath\"'", "'\"Or\"'", "'\"StringEquals\"'",
"'\"StringEqualsPath\"'", "'\"StringGreaterThan\"'",
"'\"StringGreaterThanPath\"'", "'\"StringGreaterThanEquals\"'",
"'\"StringGreaterThanEqualsPath\"'", "'\"StringLessThan\"'",
"'\"StringLessThanPath\"'", "'\"StringLessThanEquals\"'",
"'\"StringLessThanEqualsPath\"'", "'\"StringMatches\"'",
"'\"TimestampEquals\"'", "'\"TimestampEqualsPath\"'",
"'\"TimestampGreaterThan\"'", "'\"TimestampGreaterThanPath\"'",
"'\"TimestampGreaterThanEquals\"'", "'\"TimestampGreaterThanEqualsPath\"'",
"'\"TimestampLessThan\"'", "'\"TimestampLessThanPath\"'",
"'\"TimestampLessThanEquals\"'", "'\"TimestampLessThanEqualsPath\"'",
"'\"SecondsPath\"'", "'\"Seconds\"'", "'\"TimestampPath\"'",
"'\"Timestamp\"'", "'\"TimeoutSeconds\"'", "'\"TimeoutSecondsPath\"'",
"'\"HeartbeatSeconds\"'", "'\"HeartbeatSecondsPath\"'",
"'\"ProcessorConfig\"'", "'\"Mode\"'", "'\"INLINE\"'",
"'\"DISTRIBUTED\"'", "'\"ExecutionType\"'", "'\"STANDARD\"'",
"'\"ItemProcessor\"'", "'\"Iterator\"'", "'\"ItemSelector\"'",
"'\"MaxConcurrencyPath\"'", "'\"MaxConcurrency\"'",
"'\"Resource\"'", "'\"InputPath\"'", "'\"OutputPath\"'",
"'\"ItemsPath\"'", "'\"ResultPath\"'", "'\"Result\"'",
"'\"Parameters\"'", "'\"ResultSelector\"'", "'\"ItemReader\"'",
"'\"ReaderConfig\"'", "'\"InputType\"'", "'\"CSVHeaderLocation\"'",
"'\"CSVHeaders\"'", "'\"MaxItems\"'", "'\"MaxItemsPath\"'",
"'\"Next\"'", "'\"End\"'", "'\"Cause\"'", "'\"CausePath\"'",
"'\"Error\"'", "'\"ErrorPath\"'", "'\"Retry\"'", "'\"ErrorEquals\"'",
"'\"IntervalSeconds\"'", "'\"MaxAttempts\"'", "'\"BackoffRate\"'",
"'\"MaxDelaySeconds\"'", "'\"JitterStrategy\"'", "'\"FULL\"'",
"'\"NONE\"'", "'\"Catch\"'", "'\"States.ALL\"'", "'\"States.DataLimitExceeded\"'",
"'\"States.HeartbeatTimeout\"'", "'\"States.Timeout\"'",
"'\"States.TaskFailed\"'", "'\"States.Permissions\"'",
"'\"States.ResultPathMatchFailure\"'", "'\"States.ParameterPathFailure\"'",
"'\"States.BranchFailed\"'", "'\"States.NoChoiceMatched\"'",
"'\"States.IntrinsicFailure\"'", "'\"States.ExceedToleratedFailureThreshold\"'",
"'\"States.ItemReaderFailed\"'", "'\"States.ResultWriterFailed\"'",
"'\"States.Runtime\"'" ]
symbolicNames = [ "<INVALID>", "COMMA", "COLON", "LBRACK", "RBRACK",
"LBRACE", "RBRACE", "TRUE", "FALSE", "NULL", "COMMENT",
"STATES", "STARTAT", "NEXTSTATE", "VERSION", "TYPE",
"TASK", "CHOICE", "FAIL", "SUCCEED", "PASS", "WAIT",
"PARALLEL", "MAP", "CHOICES", "VARIABLE", "DEFAULT",
"BRANCHES", "AND", "BOOLEANEQUALS", "BOOLEANQUALSPATH",
"ISBOOLEAN", "ISNULL", "ISNUMERIC", "ISPRESENT", "ISSTRING",
"ISTIMESTAMP", "NOT", "NUMERICEQUALS", "NUMERICEQUALSPATH",
"NUMERICGREATERTHAN", "NUMERICGREATERTHANPATH", "NUMERICGREATERTHANEQUALS",
"NUMERICGREATERTHANEQUALSPATH", "NUMERICLESSTHAN",
"NUMERICLESSTHANPATH", "NUMERICLESSTHANEQUALS", "NUMERICLESSTHANEQUALSPATH",
"OR", "STRINGEQUALS", "STRINGEQUALSPATH", "STRINGGREATERTHAN",
"STRINGGREATERTHANPATH", "STRINGGREATERTHANEQUALS",
"STRINGGREATERTHANEQUALSPATH", "STRINGLESSTHAN", "STRINGLESSTHANPATH",
"STRINGLESSTHANEQUALS", "STRINGLESSTHANEQUALSPATH",
"STRINGMATCHES", "TIMESTAMPEQUALS", "TIMESTAMPEQUALSPATH",
"TIMESTAMPGREATERTHAN", "TIMESTAMPGREATERTHANPATH",
"TIMESTAMPGREATERTHANEQUALS", "TIMESTAMPGREATERTHANEQUALSPATH",
"TIMESTAMPLESSTHAN", "TIMESTAMPLESSTHANPATH", "TIMESTAMPLESSTHANEQUALS",
"TIMESTAMPLESSTHANEQUALSPATH", "SECONDSPATH", "SECONDS",
"TIMESTAMPPATH", "TIMESTAMP", "TIMEOUTSECONDS", "TIMEOUTSECONDSPATH",
"HEARTBEATSECONDS", "HEARTBEATSECONDSPATH", "PROCESSORCONFIG",
"MODE", "INLINE", "DISTRIBUTED", "EXECUTIONTYPE",
"STANDARD", "ITEMPROCESSOR", "ITERATOR", "ITEMSELECTOR",
"MAXCONCURRENCYPATH", "MAXCONCURRENCY", "RESOURCE",
"INPUTPATH", "OUTPUTPATH", "ITEMSPATH", "RESULTPATH",
"RESULT", "PARAMETERS", "RESULTSELECTOR", "ITEMREADER",
"READERCONFIG", "INPUTTYPE", "CSVHEADERLOCATION",
"CSVHEADERS", "MAXITEMS", "MAXITEMSPATH", "NEXT",
"END", "CAUSE", "CAUSEPATH", "ERROR", "ERRORPATH",
"RETRY", "ERROREQUALS", "INTERVALSECONDS", "MAXATTEMPTS",
"BACKOFFRATE", "MAXDELAYSECONDS", "JITTERSTRATEGY",
"FULL", "NONE", "CATCH", "ERRORNAMEStatesALL", "ERRORNAMEStatesDataLimitExceeded",
"ERRORNAMEStatesHeartbeatTimeout", "ERRORNAMEStatesTimeout",
"ERRORNAMEStatesTaskFailed", "ERRORNAMEStatesPermissions",
"ERRORNAMEStatesResultPathMatchFailure", "ERRORNAMEStatesParameterPathFailure",
"ERRORNAMEStatesBranchFailed", "ERRORNAMEStatesNoChoiceMatched",
"ERRORNAMEStatesIntrinsicFailure", "ERRORNAMEStatesExceedToleratedFailureThreshold",
"ERRORNAMEStatesItemReaderFailed", "ERRORNAMEStatesResultWriterFailed",
"ERRORNAMEStatesRuntime", "STRINGDOLLAR", "STRINGPATHCONTEXTOBJ",
"STRINGPATH", "STRING", "INT", "NUMBER", "WS" ]
RULE_state_machine = 0
RULE_program_decl = 1
RULE_top_layer_stmt = 2
RULE_startat_decl = 3
RULE_comment_decl = 4
RULE_version_decl = 5
RULE_state_stmt = 6
RULE_states_decl = 7
RULE_state_name = 8
RULE_state_decl = 9
RULE_state_decl_body = 10
RULE_type_decl = 11
RULE_next_decl = 12
RULE_resource_decl = 13
RULE_input_path_decl = 14
RULE_result_decl = 15
RULE_result_path_decl = 16
RULE_output_path_decl = 17
RULE_end_decl = 18
RULE_default_decl = 19
RULE_error_decl = 20
RULE_error_path_decl = 21
RULE_cause_decl = 22
RULE_cause_path_decl = 23
RULE_seconds_decl = 24
RULE_seconds_path_decl = 25
RULE_timestamp_decl = 26
RULE_timestamp_path_decl = 27
RULE_items_path_decl = 28
RULE_max_concurrency_decl = 29
RULE_max_concurrency_path_decl = 30
RULE_parameters_decl = 31
RULE_timeout_seconds_decl = 32
RULE_timeout_seconds_path_decl = 33
RULE_heartbeat_seconds_decl = 34
RULE_heartbeat_seconds_path_decl = 35
RULE_payload_tmpl_decl = 36
RULE_payload_binding = 37
RULE_intrinsic_func = 38
RULE_payload_arr_decl = 39
RULE_payload_value_decl = 40
RULE_payload_value_lit = 41
RULE_result_selector_decl = 42
RULE_state_type = 43
RULE_choices_decl = 44
RULE_choice_rule = 45
RULE_comparison_variable_stmt = 46
RULE_comparison_composite_stmt = 47
RULE_comparison_composite = 48
RULE_variable_decl = 49
RULE_comparison_func = 50
RULE_branches_decl = 51
RULE_item_processor_decl = 52
RULE_item_processor_item = 53
RULE_processor_config_decl = 54
RULE_processor_config_field = 55
RULE_mode_decl = 56
RULE_mode_type = 57
RULE_execution_decl = 58
RULE_execution_type = 59
RULE_iterator_decl = 60
RULE_iterator_decl_item = 61
RULE_item_selector_decl = 62
RULE_item_reader_decl = 63
RULE_items_reader_field = 64
RULE_reader_config_decl = 65
RULE_reader_config_field = 66
RULE_input_type_decl = 67
RULE_csv_header_location_decl = 68
RULE_csv_headers_decl = 69
RULE_max_items_decl = 70
RULE_max_items_path_decl = 71
RULE_retry_decl = 72
RULE_retrier_decl = 73
RULE_retrier_stmt = 74
RULE_error_equals_decl = 75
RULE_interval_seconds_decl = 76
RULE_max_attempts_decl = 77
RULE_backoff_rate_decl = 78
RULE_max_delay_seconds_decl = 79
RULE_jitter_strategy_decl = 80
RULE_catch_decl = 81
RULE_catcher_decl = 82
RULE_catcher_stmt = 83
RULE_comparison_op = 84
RULE_choice_operator = 85
RULE_states_error_name = 86
RULE_error_name = 87
RULE_json_obj_decl = 88
RULE_json_binding = 89
RULE_json_arr_decl = 90
RULE_json_value_decl = 91
RULE_keyword_or_string = 92
ruleNames = [ "state_machine", "program_decl", "top_layer_stmt", "startat_decl",
"comment_decl", "version_decl", "state_stmt", "states_decl",
"state_name", "state_decl", "state_decl_body", "type_decl",
"next_decl", "resource_decl", "input_path_decl", "result_decl",
"result_path_decl", "output_path_decl", "end_decl", "default_decl",
"error_decl", "error_path_decl", "cause_decl", "cause_path_decl",
"seconds_decl", "seconds_path_decl", "timestamp_decl",
"timestamp_path_decl", "items_path_decl", "max_concurrency_decl",
"max_concurrency_path_decl", "parameters_decl", "timeout_seconds_decl",
"timeout_seconds_path_decl", "heartbeat_seconds_decl",
"heartbeat_seconds_path_decl", "payload_tmpl_decl", "payload_binding",
"intrinsic_func", "payload_arr_decl", "payload_value_decl",
"payload_value_lit", "result_selector_decl", "state_type",
"choices_decl", "choice_rule", "comparison_variable_stmt",
"comparison_composite_stmt", "comparison_composite",
"variable_decl", "comparison_func", "branches_decl",
"item_processor_decl", "item_processor_item", "processor_config_decl",
"processor_config_field", "mode_decl", "mode_type", "execution_decl",
"execution_type", "iterator_decl", "iterator_decl_item",
"item_selector_decl", "item_reader_decl", "items_reader_field",
"reader_config_decl", "reader_config_field", "input_type_decl",
"csv_header_location_decl", "csv_headers_decl", "max_items_decl",
"max_items_path_decl", "retry_decl", "retrier_decl",
"retrier_stmt", "error_equals_decl", "interval_seconds_decl",
"max_attempts_decl", "backoff_rate_decl", "max_delay_seconds_decl",
"jitter_strategy_decl", "catch_decl", "catcher_decl",
"catcher_stmt", "comparison_op", "choice_operator", "states_error_name",
"error_name", "json_obj_decl", "json_binding", "json_arr_decl",
"json_value_decl", "keyword_or_string" ]
EOF = Token.EOF
COMMA=1
COLON=2
LBRACK=3
RBRACK=4
LBRACE=5
RBRACE=6
TRUE=7
FALSE=8
NULL=9
COMMENT=10
STATES=11
STARTAT=12
NEXTSTATE=13
VERSION=14
TYPE=15
TASK=16
CHOICE=17
FAIL=18
SUCCEED=19
PASS=20
WAIT=21
PARALLEL=22
MAP=23
CHOICES=24
VARIABLE=25
DEFAULT=26
BRANCHES=27
AND=28
BOOLEANEQUALS=29
BOOLEANQUALSPATH=30
ISBOOLEAN=31
ISNULL=32
ISNUMERIC=33
ISPRESENT=34
ISSTRING=35
ISTIMESTAMP=36
NOT=37
NUMERICEQUALS=38
NUMERICEQUALSPATH=39
NUMERICGREATERTHAN=40
NUMERICGREATERTHANPATH=41
NUMERICGREATERTHANEQUALS=42
NUMERICGREATERTHANEQUALSPATH=43
NUMERICLESSTHAN=44
NUMERICLESSTHANPATH=45
NUMERICLESSTHANEQUALS=46
NUMERICLESSTHANEQUALSPATH=47
OR=48
STRINGEQUALS=49
STRINGEQUALSPATH=50
STRINGGREATERTHAN=51
STRINGGREATERTHANPATH=52
STRINGGREATERTHANEQUALS=53
STRINGGREATERTHANEQUALSPATH=54
STRINGLESSTHAN=55
STRINGLESSTHANPATH=56
STRINGLESSTHANEQUALS=57
STRINGLESSTHANEQUALSPATH=58
STRINGMATCHES=59
TIMESTAMPEQUALS=60
TIMESTAMPEQUALSPATH=61
TIMESTAMPGREATERTHAN=62
TIMESTAMPGREATERTHANPATH=63
TIMESTAMPGREATERTHANEQUALS=64
TIMESTAMPGREATERTHANEQUALSPATH=65
TIMESTAMPLESSTHAN=66
TIMESTAMPLESSTHANPATH=67
TIMESTAMPLESSTHANEQUALS=68
TIMESTAMPLESSTHANEQUALSPATH=69
SECONDSPATH=70
SECONDS=71
TIMESTAMPPATH=72
TIMESTAMP=73
TIMEOUTSECONDS=74
TIMEOUTSECONDSPATH=75
HEARTBEATSECONDS=76
HEARTBEATSECONDSPATH=77
PROCESSORCONFIG=78
MODE=79
INLINE=80
DISTRIBUTED=81
EXECUTIONTYPE=82
STANDARD=83
ITEMPROCESSOR=84
ITERATOR=85
ITEMSELECTOR=86
MAXCONCURRENCYPATH=87
MAXCONCURRENCY=88
RESOURCE=89
INPUTPATH=90
OUTPUTPATH=91
ITEMSPATH=92
RESULTPATH=93
RESULT=94
PARAMETERS=95
RESULTSELECTOR=96
ITEMREADER=97
READERCONFIG=98
INPUTTYPE=99
CSVHEADERLOCATION=100
CSVHEADERS=101
MAXITEMS=102
MAXITEMSPATH=103
NEXT=104
END=105
CAUSE=106
CAUSEPATH=107
ERROR=108
ERRORPATH=109
RETRY=110
ERROREQUALS=111
INTERVALSECONDS=112
MAXATTEMPTS=113
BACKOFFRATE=114
MAXDELAYSECONDS=115
JITTERSTRATEGY=116
FULL=117
NONE=118
CATCH=119
ERRORNAMEStatesALL=120
ERRORNAMEStatesDataLimitExceeded=121
ERRORNAMEStatesHeartbeatTimeout=122
ERRORNAMEStatesTimeout=123
ERRORNAMEStatesTaskFailed=124
ERRORNAMEStatesPermissions=125
ERRORNAMEStatesResultPathMatchFailure=126
ERRORNAMEStatesParameterPathFailure=127
ERRORNAMEStatesBranchFailed=128
ERRORNAMEStatesNoChoiceMatched=129
ERRORNAMEStatesIntrinsicFailure=130
ERRORNAMEStatesExceedToleratedFailureThreshold=131
ERRORNAMEStatesItemReaderFailed=132
ERRORNAMEStatesResultWriterFailed=133
ERRORNAMEStatesRuntime=134
STRINGDOLLAR=135
STRINGPATHCONTEXTOBJ=136
STRINGPATH=137
STRING=138
INT=139
NUMBER=140
WS=141
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.13.1")
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
self._predicates = None
class State_machineContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def program_decl(self):
return self.getTypedRuleContext(ASLParser.Program_declContext,0)
def EOF(self):
return self.getToken(ASLParser.EOF, 0)
def getRuleIndex(self):
return ASLParser.RULE_state_machine
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterState_machine" ):
listener.enterState_machine(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitState_machine" ):
listener.exitState_machine(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitState_machine" ):
return visitor.visitState_machine(self)
else:
return visitor.visitChildren(self)
def state_machine(self):
localctx = ASLParser.State_machineContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_state_machine)
try:
self.enterOuterAlt(localctx, 1)
self.state = 186
self.program_decl()
self.state = 187
self.match(ASLParser.EOF)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Program_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def top_layer_stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Top_layer_stmtContext)
else:
return self.getTypedRuleContext(ASLParser.Top_layer_stmtContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_program_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProgram_decl" ):
listener.enterProgram_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProgram_decl" ):
listener.exitProgram_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProgram_decl" ):
return visitor.visitProgram_decl(self)
else:
return visitor.visitChildren(self)
def program_decl(self):
localctx = ASLParser.Program_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_program_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 189
self.match(ASLParser.LBRACE)
self.state = 190
self.top_layer_stmt()
self.state = 195
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 191
self.match(ASLParser.COMMA)
self.state = 192
self.top_layer_stmt()
self.state = 197
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 198
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Top_layer_stmtContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def comment_decl(self):
return self.getTypedRuleContext(ASLParser.Comment_declContext,0)
def version_decl(self):
return self.getTypedRuleContext(ASLParser.Version_declContext,0)
def startat_decl(self):
return self.getTypedRuleContext(ASLParser.Startat_declContext,0)
def states_decl(self):
return self.getTypedRuleContext(ASLParser.States_declContext,0)
def timeout_seconds_decl(self):
return self.getTypedRuleContext(ASLParser.Timeout_seconds_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_top_layer_stmt
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTop_layer_stmt" ):
listener.enterTop_layer_stmt(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTop_layer_stmt" ):
listener.exitTop_layer_stmt(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTop_layer_stmt" ):
return visitor.visitTop_layer_stmt(self)
else:
return visitor.visitChildren(self)
def top_layer_stmt(self):
localctx = ASLParser.Top_layer_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_top_layer_stmt)
try:
self.state = 205
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [10]:
self.enterOuterAlt(localctx, 1)
self.state = 200
self.comment_decl()
pass
elif token in [14]:
self.enterOuterAlt(localctx, 2)
self.state = 201
self.version_decl()
pass
elif token in [12]:
self.enterOuterAlt(localctx, 3)
self.state = 202
self.startat_decl()
pass
elif token in [11]:
self.enterOuterAlt(localctx, 4)
self.state = 203
self.states_decl()
pass
elif token in [74]:
self.enterOuterAlt(localctx, 5)
self.state = 204
self.timeout_seconds_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Startat_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def STARTAT(self):
return self.getToken(ASLParser.STARTAT, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_startat_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStartat_decl" ):
listener.enterStartat_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStartat_decl" ):
listener.exitStartat_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStartat_decl" ):
return visitor.visitStartat_decl(self)
else:
return visitor.visitChildren(self)
def startat_decl(self):
localctx = ASLParser.Startat_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_startat_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 207
self.match(ASLParser.STARTAT)
self.state = 208
self.match(ASLParser.COLON)
self.state = 209
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Comment_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def COMMENT(self):
return self.getToken(ASLParser.COMMENT, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_comment_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComment_decl" ):
listener.enterComment_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComment_decl" ):
listener.exitComment_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComment_decl" ):
return visitor.visitComment_decl(self)
else:
return visitor.visitChildren(self)
def comment_decl(self):
localctx = ASLParser.Comment_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_comment_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 211
self.match(ASLParser.COMMENT)
self.state = 212
self.match(ASLParser.COLON)
self.state = 213
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Version_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def VERSION(self):
return self.getToken(ASLParser.VERSION, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_version_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVersion_decl" ):
listener.enterVersion_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVersion_decl" ):
listener.exitVersion_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVersion_decl" ):
return visitor.visitVersion_decl(self)
else:
return visitor.visitChildren(self)
def version_decl(self):
localctx = ASLParser.Version_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 10, self.RULE_version_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 215
self.match(ASLParser.VERSION)
self.state = 216
self.match(ASLParser.COLON)
self.state = 217
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class State_stmtContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def comment_decl(self):
return self.getTypedRuleContext(ASLParser.Comment_declContext,0)
def type_decl(self):
return self.getTypedRuleContext(ASLParser.Type_declContext,0)
def input_path_decl(self):
return self.getTypedRuleContext(ASLParser.Input_path_declContext,0)
def resource_decl(self):
return self.getTypedRuleContext(ASLParser.Resource_declContext,0)
def next_decl(self):
return self.getTypedRuleContext(ASLParser.Next_declContext,0)
def result_decl(self):
return self.getTypedRuleContext(ASLParser.Result_declContext,0)
def result_path_decl(self):
return self.getTypedRuleContext(ASLParser.Result_path_declContext,0)
def output_path_decl(self):
return self.getTypedRuleContext(ASLParser.Output_path_declContext,0)
def end_decl(self):
return self.getTypedRuleContext(ASLParser.End_declContext,0)
def default_decl(self):
return self.getTypedRuleContext(ASLParser.Default_declContext,0)
def choices_decl(self):
return self.getTypedRuleContext(ASLParser.Choices_declContext,0)
def error_decl(self):
return self.getTypedRuleContext(ASLParser.Error_declContext,0)
def error_path_decl(self):
return self.getTypedRuleContext(ASLParser.Error_path_declContext,0)
def cause_decl(self):
return self.getTypedRuleContext(ASLParser.Cause_declContext,0)
def cause_path_decl(self):
return self.getTypedRuleContext(ASLParser.Cause_path_declContext,0)
def seconds_decl(self):
return self.getTypedRuleContext(ASLParser.Seconds_declContext,0)
def seconds_path_decl(self):
return self.getTypedRuleContext(ASLParser.Seconds_path_declContext,0)
def timestamp_decl(self):
return self.getTypedRuleContext(ASLParser.Timestamp_declContext,0)
def timestamp_path_decl(self):
return self.getTypedRuleContext(ASLParser.Timestamp_path_declContext,0)
def items_path_decl(self):
return self.getTypedRuleContext(ASLParser.Items_path_declContext,0)
def item_processor_decl(self):
return self.getTypedRuleContext(ASLParser.Item_processor_declContext,0)
def iterator_decl(self):
return self.getTypedRuleContext(ASLParser.Iterator_declContext,0)
def item_selector_decl(self):
return self.getTypedRuleContext(ASLParser.Item_selector_declContext,0)
def item_reader_decl(self):
return self.getTypedRuleContext(ASLParser.Item_reader_declContext,0)
def max_concurrency_decl(self):
return self.getTypedRuleContext(ASLParser.Max_concurrency_declContext,0)
def max_concurrency_path_decl(self):
return self.getTypedRuleContext(ASLParser.Max_concurrency_path_declContext,0)
def timeout_seconds_decl(self):
return self.getTypedRuleContext(ASLParser.Timeout_seconds_declContext,0)
def timeout_seconds_path_decl(self):
return self.getTypedRuleContext(ASLParser.Timeout_seconds_path_declContext,0)
def heartbeat_seconds_decl(self):
return self.getTypedRuleContext(ASLParser.Heartbeat_seconds_declContext,0)
def heartbeat_seconds_path_decl(self):
return self.getTypedRuleContext(ASLParser.Heartbeat_seconds_path_declContext,0)
def branches_decl(self):
return self.getTypedRuleContext(ASLParser.Branches_declContext,0)
def parameters_decl(self):
return self.getTypedRuleContext(ASLParser.Parameters_declContext,0)
def retry_decl(self):
return self.getTypedRuleContext(ASLParser.Retry_declContext,0)
def catch_decl(self):
return self.getTypedRuleContext(ASLParser.Catch_declContext,0)
def result_selector_decl(self):
return self.getTypedRuleContext(ASLParser.Result_selector_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_state_stmt
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterState_stmt" ):
listener.enterState_stmt(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitState_stmt" ):
listener.exitState_stmt(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitState_stmt" ):
return visitor.visitState_stmt(self)
else:
return visitor.visitChildren(self)
def state_stmt(self):
localctx = ASLParser.State_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_state_stmt)
try:
self.state = 254
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [10]:
self.enterOuterAlt(localctx, 1)
self.state = 219
self.comment_decl()
pass
elif token in [15]:
self.enterOuterAlt(localctx, 2)
self.state = 220
self.type_decl()
pass
elif token in [90]:
self.enterOuterAlt(localctx, 3)
self.state = 221
self.input_path_decl()
pass
elif token in [89]:
self.enterOuterAlt(localctx, 4)
self.state = 222
self.resource_decl()
pass
elif token in [104]:
self.enterOuterAlt(localctx, 5)
self.state = 223
self.next_decl()
pass
elif token in [94]:
self.enterOuterAlt(localctx, 6)
self.state = 224
self.result_decl()
pass
elif token in [93]:
self.enterOuterAlt(localctx, 7)
self.state = 225
self.result_path_decl()
pass
elif token in [91]:
self.enterOuterAlt(localctx, 8)
self.state = 226
self.output_path_decl()
pass
elif token in [105]:
self.enterOuterAlt(localctx, 9)
self.state = 227
self.end_decl()
pass
elif token in [26]:
self.enterOuterAlt(localctx, 10)
self.state = 228
self.default_decl()
pass
elif token in [24]:
self.enterOuterAlt(localctx, 11)
self.state = 229
self.choices_decl()
pass
elif token in [108]:
self.enterOuterAlt(localctx, 12)
self.state = 230
self.error_decl()
pass
elif token in [109]:
self.enterOuterAlt(localctx, 13)
self.state = 231
self.error_path_decl()
pass
elif token in [106]:
self.enterOuterAlt(localctx, 14)
self.state = 232
self.cause_decl()
pass
elif token in [107]:
self.enterOuterAlt(localctx, 15)
self.state = 233
self.cause_path_decl()
pass
elif token in [71]:
self.enterOuterAlt(localctx, 16)
self.state = 234
self.seconds_decl()
pass
elif token in [70]:
self.enterOuterAlt(localctx, 17)
self.state = 235
self.seconds_path_decl()
pass
elif token in [73]:
self.enterOuterAlt(localctx, 18)
self.state = 236
self.timestamp_decl()
pass
elif token in [72]:
self.enterOuterAlt(localctx, 19)
self.state = 237
self.timestamp_path_decl()
pass
elif token in [92]:
self.enterOuterAlt(localctx, 20)
self.state = 238
self.items_path_decl()
pass
elif token in [84]:
self.enterOuterAlt(localctx, 21)
self.state = 239
self.item_processor_decl()
pass
elif token in [85]:
self.enterOuterAlt(localctx, 22)
self.state = 240
self.iterator_decl()
pass
elif token in [86]:
self.enterOuterAlt(localctx, 23)
self.state = 241
self.item_selector_decl()
pass
elif token in [97]:
self.enterOuterAlt(localctx, 24)
self.state = 242
self.item_reader_decl()
pass
elif token in [88]:
self.enterOuterAlt(localctx, 25)
self.state = 243
self.max_concurrency_decl()
pass
elif token in [87]:
self.enterOuterAlt(localctx, 26)
self.state = 244
self.max_concurrency_path_decl()
pass
elif token in [74]:
self.enterOuterAlt(localctx, 27)
self.state = 245
self.timeout_seconds_decl()
pass
elif token in [75]:
self.enterOuterAlt(localctx, 28)
self.state = 246
self.timeout_seconds_path_decl()
pass
elif token in [76]:
self.enterOuterAlt(localctx, 29)
self.state = 247
self.heartbeat_seconds_decl()
pass
elif token in [77]:
self.enterOuterAlt(localctx, 30)
self.state = 248
self.heartbeat_seconds_path_decl()
pass
elif token in [27]:
self.enterOuterAlt(localctx, 31)
self.state = 249
self.branches_decl()
pass
elif token in [95]:
self.enterOuterAlt(localctx, 32)
self.state = 250
self.parameters_decl()
pass
elif token in [110]:
self.enterOuterAlt(localctx, 33)
self.state = 251
self.retry_decl()
pass
elif token in [119]:
self.enterOuterAlt(localctx, 34)
self.state = 252
self.catch_decl()
pass
elif token in [96]:
self.enterOuterAlt(localctx, 35)
self.state = 253
self.result_selector_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class States_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def STATES(self):
return self.getToken(ASLParser.STATES, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def state_decl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.State_declContext)
else:
return self.getTypedRuleContext(ASLParser.State_declContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_states_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStates_decl" ):
listener.enterStates_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStates_decl" ):
listener.exitStates_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStates_decl" ):
return visitor.visitStates_decl(self)
else:
return visitor.visitChildren(self)
def states_decl(self):
localctx = ASLParser.States_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_states_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 256
self.match(ASLParser.STATES)
self.state = 257
self.match(ASLParser.COLON)
self.state = 258
self.match(ASLParser.LBRACE)
self.state = 259
self.state_decl()
self.state = 264
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 260
self.match(ASLParser.COMMA)
self.state = 261
self.state_decl()
self.state = 266
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 267
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class State_nameContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_state_name
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterState_name" ):
listener.enterState_name(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitState_name" ):
listener.exitState_name(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitState_name" ):
return visitor.visitState_name(self)
else:
return visitor.visitChildren(self)
def state_name(self):
localctx = ASLParser.State_nameContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_state_name)
try:
self.enterOuterAlt(localctx, 1)
self.state = 269
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class State_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def state_name(self):
return self.getTypedRuleContext(ASLParser.State_nameContext,0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def state_decl_body(self):
return self.getTypedRuleContext(ASLParser.State_decl_bodyContext,0)
def getRuleIndex(self):
return ASLParser.RULE_state_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterState_decl" ):
listener.enterState_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitState_decl" ):
listener.exitState_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitState_decl" ):
return visitor.visitState_decl(self)
else:
return visitor.visitChildren(self)
def state_decl(self):
localctx = ASLParser.State_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_state_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 271
self.state_name()
self.state = 272
self.match(ASLParser.COLON)
self.state = 273
self.state_decl_body()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class State_decl_bodyContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def state_stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.State_stmtContext)
else:
return self.getTypedRuleContext(ASLParser.State_stmtContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_state_decl_body
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterState_decl_body" ):
listener.enterState_decl_body(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitState_decl_body" ):
listener.exitState_decl_body(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitState_decl_body" ):
return visitor.visitState_decl_body(self)
else:
return visitor.visitChildren(self)
def state_decl_body(self):
localctx = ASLParser.State_decl_bodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_state_decl_body)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 275
self.match(ASLParser.LBRACE)
self.state = 276
self.state_stmt()
self.state = 281
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 277
self.match(ASLParser.COMMA)
self.state = 278
self.state_stmt()
self.state = 283
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 284
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Type_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def TYPE(self):
return self.getToken(ASLParser.TYPE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def state_type(self):
return self.getTypedRuleContext(ASLParser.State_typeContext,0)
def getRuleIndex(self):
return ASLParser.RULE_type_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterType_decl" ):
listener.enterType_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitType_decl" ):
listener.exitType_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitType_decl" ):
return visitor.visitType_decl(self)
else:
return visitor.visitChildren(self)
def type_decl(self):
localctx = ASLParser.Type_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_type_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 286
self.match(ASLParser.TYPE)
self.state = 287
self.match(ASLParser.COLON)
self.state = 288
self.state_type()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Next_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def NEXT(self):
return self.getToken(ASLParser.NEXT, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_next_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNext_decl" ):
listener.enterNext_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNext_decl" ):
listener.exitNext_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNext_decl" ):
return visitor.visitNext_decl(self)
else:
return visitor.visitChildren(self)
def next_decl(self):
localctx = ASLParser.Next_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_next_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 290
self.match(ASLParser.NEXT)
self.state = 291
self.match(ASLParser.COLON)
self.state = 292
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Resource_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def RESOURCE(self):
return self.getToken(ASLParser.RESOURCE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_resource_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterResource_decl" ):
listener.enterResource_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitResource_decl" ):
listener.exitResource_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitResource_decl" ):
return visitor.visitResource_decl(self)
else:
return visitor.visitChildren(self)
def resource_decl(self):
localctx = ASLParser.Resource_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_resource_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 294
self.match(ASLParser.RESOURCE)
self.state = 295
self.match(ASLParser.COLON)
self.state = 296
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Input_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def INPUTPATH(self):
return self.getToken(ASLParser.INPUTPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def NULL(self):
return self.getToken(ASLParser.NULL, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_input_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInput_path_decl" ):
listener.enterInput_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInput_path_decl" ):
listener.exitInput_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInput_path_decl" ):
return visitor.visitInput_path_decl(self)
else:
return visitor.visitChildren(self)
def input_path_decl(self):
localctx = ASLParser.Input_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_input_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 298
self.match(ASLParser.INPUTPATH)
self.state = 299
self.match(ASLParser.COLON)
self.state = 302
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [9]:
self.state = 300
self.match(ASLParser.NULL)
pass
elif token in [10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138]:
self.state = 301
self.keyword_or_string()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Result_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def RESULT(self):
return self.getToken(ASLParser.RESULT, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def json_value_decl(self):
return self.getTypedRuleContext(ASLParser.Json_value_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_result_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterResult_decl" ):
listener.enterResult_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitResult_decl" ):
listener.exitResult_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitResult_decl" ):
return visitor.visitResult_decl(self)
else:
return visitor.visitChildren(self)
def result_decl(self):
localctx = ASLParser.Result_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_result_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 304
self.match(ASLParser.RESULT)
self.state = 305
self.match(ASLParser.COLON)
self.state = 306
self.json_value_decl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Result_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def RESULTPATH(self):
return self.getToken(ASLParser.RESULTPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def NULL(self):
return self.getToken(ASLParser.NULL, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_result_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterResult_path_decl" ):
listener.enterResult_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitResult_path_decl" ):
listener.exitResult_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitResult_path_decl" ):
return visitor.visitResult_path_decl(self)
else:
return visitor.visitChildren(self)
def result_path_decl(self):
localctx = ASLParser.Result_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_result_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 308
self.match(ASLParser.RESULTPATH)
self.state = 309
self.match(ASLParser.COLON)
self.state = 312
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [9]:
self.state = 310
self.match(ASLParser.NULL)
pass
elif token in [10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138]:
self.state = 311
self.keyword_or_string()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Output_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def OUTPUTPATH(self):
return self.getToken(ASLParser.OUTPUTPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def NULL(self):
return self.getToken(ASLParser.NULL, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_output_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterOutput_path_decl" ):
listener.enterOutput_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitOutput_path_decl" ):
listener.exitOutput_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOutput_path_decl" ):
return visitor.visitOutput_path_decl(self)
else:
return visitor.visitChildren(self)
def output_path_decl(self):
localctx = ASLParser.Output_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 34, self.RULE_output_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 314
self.match(ASLParser.OUTPUTPATH)
self.state = 315
self.match(ASLParser.COLON)
self.state = 318
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [9]:
self.state = 316
self.match(ASLParser.NULL)
pass
elif token in [10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138]:
self.state = 317
self.keyword_or_string()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class End_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def END(self):
return self.getToken(ASLParser.END, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def TRUE(self):
return self.getToken(ASLParser.TRUE, 0)
def FALSE(self):
return self.getToken(ASLParser.FALSE, 0)
def getRuleIndex(self):
return ASLParser.RULE_end_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEnd_decl" ):
listener.enterEnd_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEnd_decl" ):
listener.exitEnd_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEnd_decl" ):
return visitor.visitEnd_decl(self)
else:
return visitor.visitChildren(self)
def end_decl(self):
localctx = ASLParser.End_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 36, self.RULE_end_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 320
self.match(ASLParser.END)
self.state = 321
self.match(ASLParser.COLON)
self.state = 322
_la = self._input.LA(1)
if not(_la==7 or _la==8):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Default_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def DEFAULT(self):
return self.getToken(ASLParser.DEFAULT, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_default_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDefault_decl" ):
listener.enterDefault_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDefault_decl" ):
listener.exitDefault_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDefault_decl" ):
return visitor.visitDefault_decl(self)
else:
return visitor.visitChildren(self)
def default_decl(self):
localctx = ASLParser.Default_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 38, self.RULE_default_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 324
self.match(ASLParser.DEFAULT)
self.state = 325
self.match(ASLParser.COLON)
self.state = 326
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Error_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ERROR(self):
return self.getToken(ASLParser.ERROR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_error_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterError_decl" ):
listener.enterError_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitError_decl" ):
listener.exitError_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitError_decl" ):
return visitor.visitError_decl(self)
else:
return visitor.visitChildren(self)
def error_decl(self):
localctx = ASLParser.Error_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_error_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 328
self.match(ASLParser.ERROR)
self.state = 329
self.match(ASLParser.COLON)
self.state = 330
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Error_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return ASLParser.RULE_error_path_decl
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class Error_path_decl_intrinsicContext(Error_path_declContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Error_path_declContext
super().__init__(parser)
self.copyFrom(ctx)
def ERRORPATH(self):
return self.getToken(ASLParser.ERRORPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def intrinsic_func(self):
return self.getTypedRuleContext(ASLParser.Intrinsic_funcContext,0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterError_path_decl_intrinsic" ):
listener.enterError_path_decl_intrinsic(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitError_path_decl_intrinsic" ):
listener.exitError_path_decl_intrinsic(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitError_path_decl_intrinsic" ):
return visitor.visitError_path_decl_intrinsic(self)
else:
return visitor.visitChildren(self)
class Error_path_decl_pathContext(Error_path_declContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Error_path_declContext
super().__init__(parser)
self.copyFrom(ctx)
def ERRORPATH(self):
return self.getToken(ASLParser.ERRORPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterError_path_decl_path" ):
listener.enterError_path_decl_path(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitError_path_decl_path" ):
listener.exitError_path_decl_path(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitError_path_decl_path" ):
return visitor.visitError_path_decl_path(self)
else:
return visitor.visitChildren(self)
def error_path_decl(self):
localctx = ASLParser.Error_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 42, self.RULE_error_path_decl)
try:
self.state = 338
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
if la_ == 1:
localctx = ASLParser.Error_path_decl_pathContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 332
self.match(ASLParser.ERRORPATH)
self.state = 333
self.match(ASLParser.COLON)
self.state = 334
self.match(ASLParser.STRINGPATH)
pass
elif la_ == 2:
localctx = ASLParser.Error_path_decl_intrinsicContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 335
self.match(ASLParser.ERRORPATH)
self.state = 336
self.match(ASLParser.COLON)
self.state = 337
self.intrinsic_func()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Cause_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def CAUSE(self):
return self.getToken(ASLParser.CAUSE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_cause_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCause_decl" ):
listener.enterCause_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCause_decl" ):
listener.exitCause_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCause_decl" ):
return visitor.visitCause_decl(self)
else:
return visitor.visitChildren(self)
def cause_decl(self):
localctx = ASLParser.Cause_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_cause_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 340
self.match(ASLParser.CAUSE)
self.state = 341
self.match(ASLParser.COLON)
self.state = 342
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Cause_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return ASLParser.RULE_cause_path_decl
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class Cause_path_decl_pathContext(Cause_path_declContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Cause_path_declContext
super().__init__(parser)
self.copyFrom(ctx)
def CAUSEPATH(self):
return self.getToken(ASLParser.CAUSEPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCause_path_decl_path" ):
listener.enterCause_path_decl_path(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCause_path_decl_path" ):
listener.exitCause_path_decl_path(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCause_path_decl_path" ):
return visitor.visitCause_path_decl_path(self)
else:
return visitor.visitChildren(self)
class Cause_path_decl_intrinsicContext(Cause_path_declContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Cause_path_declContext
super().__init__(parser)
self.copyFrom(ctx)
def CAUSEPATH(self):
return self.getToken(ASLParser.CAUSEPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def intrinsic_func(self):
return self.getTypedRuleContext(ASLParser.Intrinsic_funcContext,0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCause_path_decl_intrinsic" ):
listener.enterCause_path_decl_intrinsic(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCause_path_decl_intrinsic" ):
listener.exitCause_path_decl_intrinsic(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCause_path_decl_intrinsic" ):
return visitor.visitCause_path_decl_intrinsic(self)
else:
return visitor.visitChildren(self)
def cause_path_decl(self):
localctx = ASLParser.Cause_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_cause_path_decl)
try:
self.state = 350
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
if la_ == 1:
localctx = ASLParser.Cause_path_decl_pathContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 344
self.match(ASLParser.CAUSEPATH)
self.state = 345
self.match(ASLParser.COLON)
self.state = 346
self.match(ASLParser.STRINGPATH)
pass
elif la_ == 2:
localctx = ASLParser.Cause_path_decl_intrinsicContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 347
self.match(ASLParser.CAUSEPATH)
self.state = 348
self.match(ASLParser.COLON)
self.state = 349
self.intrinsic_func()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Seconds_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def SECONDS(self):
return self.getToken(ASLParser.SECONDS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_seconds_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSeconds_decl" ):
listener.enterSeconds_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSeconds_decl" ):
listener.exitSeconds_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSeconds_decl" ):
return visitor.visitSeconds_decl(self)
else:
return visitor.visitChildren(self)
def seconds_decl(self):
localctx = ASLParser.Seconds_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 48, self.RULE_seconds_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 352
self.match(ASLParser.SECONDS)
self.state = 353
self.match(ASLParser.COLON)
self.state = 354
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Seconds_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def SECONDSPATH(self):
return self.getToken(ASLParser.SECONDSPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_seconds_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSeconds_path_decl" ):
listener.enterSeconds_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSeconds_path_decl" ):
listener.exitSeconds_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSeconds_path_decl" ):
return visitor.visitSeconds_path_decl(self)
else:
return visitor.visitChildren(self)
def seconds_path_decl(self):
localctx = ASLParser.Seconds_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 50, self.RULE_seconds_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 356
self.match(ASLParser.SECONDSPATH)
self.state = 357
self.match(ASLParser.COLON)
self.state = 358
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Timestamp_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def TIMESTAMP(self):
return self.getToken(ASLParser.TIMESTAMP, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_timestamp_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTimestamp_decl" ):
listener.enterTimestamp_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTimestamp_decl" ):
listener.exitTimestamp_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTimestamp_decl" ):
return visitor.visitTimestamp_decl(self)
else:
return visitor.visitChildren(self)
def timestamp_decl(self):
localctx = ASLParser.Timestamp_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 52, self.RULE_timestamp_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 360
self.match(ASLParser.TIMESTAMP)
self.state = 361
self.match(ASLParser.COLON)
self.state = 362
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Timestamp_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def TIMESTAMPPATH(self):
return self.getToken(ASLParser.TIMESTAMPPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_timestamp_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTimestamp_path_decl" ):
listener.enterTimestamp_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTimestamp_path_decl" ):
listener.exitTimestamp_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTimestamp_path_decl" ):
return visitor.visitTimestamp_path_decl(self)
else:
return visitor.visitChildren(self)
def timestamp_path_decl(self):
localctx = ASLParser.Timestamp_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_timestamp_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 364
self.match(ASLParser.TIMESTAMPPATH)
self.state = 365
self.match(ASLParser.COLON)
self.state = 366
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Items_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ITEMSPATH(self):
return self.getToken(ASLParser.ITEMSPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_items_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterItems_path_decl" ):
listener.enterItems_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitItems_path_decl" ):
listener.exitItems_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitItems_path_decl" ):
return visitor.visitItems_path_decl(self)
else:
return visitor.visitChildren(self)
def items_path_decl(self):
localctx = ASLParser.Items_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 56, self.RULE_items_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 368
self.match(ASLParser.ITEMSPATH)
self.state = 369
self.match(ASLParser.COLON)
self.state = 370
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Max_concurrency_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def MAXCONCURRENCY(self):
return self.getToken(ASLParser.MAXCONCURRENCY, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_max_concurrency_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMax_concurrency_decl" ):
listener.enterMax_concurrency_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMax_concurrency_decl" ):
listener.exitMax_concurrency_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMax_concurrency_decl" ):
return visitor.visitMax_concurrency_decl(self)
else:
return visitor.visitChildren(self)
def max_concurrency_decl(self):
localctx = ASLParser.Max_concurrency_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 58, self.RULE_max_concurrency_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 372
self.match(ASLParser.MAXCONCURRENCY)
self.state = 373
self.match(ASLParser.COLON)
self.state = 374
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Max_concurrency_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def MAXCONCURRENCYPATH(self):
return self.getToken(ASLParser.MAXCONCURRENCYPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def getRuleIndex(self):
return ASLParser.RULE_max_concurrency_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMax_concurrency_path_decl" ):
listener.enterMax_concurrency_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMax_concurrency_path_decl" ):
listener.exitMax_concurrency_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMax_concurrency_path_decl" ):
return visitor.visitMax_concurrency_path_decl(self)
else:
return visitor.visitChildren(self)
def max_concurrency_path_decl(self):
localctx = ASLParser.Max_concurrency_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_max_concurrency_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 376
self.match(ASLParser.MAXCONCURRENCYPATH)
self.state = 377
self.match(ASLParser.COLON)
self.state = 378
self.match(ASLParser.STRINGPATH)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Parameters_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def PARAMETERS(self):
return self.getToken(ASLParser.PARAMETERS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def payload_tmpl_decl(self):
return self.getTypedRuleContext(ASLParser.Payload_tmpl_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_parameters_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterParameters_decl" ):
listener.enterParameters_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitParameters_decl" ):
listener.exitParameters_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParameters_decl" ):
return visitor.visitParameters_decl(self)
else:
return visitor.visitChildren(self)
def parameters_decl(self):
localctx = ASLParser.Parameters_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 62, self.RULE_parameters_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 380
self.match(ASLParser.PARAMETERS)
self.state = 381
self.match(ASLParser.COLON)
self.state = 382
self.payload_tmpl_decl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Timeout_seconds_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def TIMEOUTSECONDS(self):
return self.getToken(ASLParser.TIMEOUTSECONDS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_timeout_seconds_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTimeout_seconds_decl" ):
listener.enterTimeout_seconds_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTimeout_seconds_decl" ):
listener.exitTimeout_seconds_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTimeout_seconds_decl" ):
return visitor.visitTimeout_seconds_decl(self)
else:
return visitor.visitChildren(self)
def timeout_seconds_decl(self):
localctx = ASLParser.Timeout_seconds_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 64, self.RULE_timeout_seconds_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 384
self.match(ASLParser.TIMEOUTSECONDS)
self.state = 385
self.match(ASLParser.COLON)
self.state = 386
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Timeout_seconds_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def TIMEOUTSECONDSPATH(self):
return self.getToken(ASLParser.TIMEOUTSECONDSPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def getRuleIndex(self):
return ASLParser.RULE_timeout_seconds_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTimeout_seconds_path_decl" ):
listener.enterTimeout_seconds_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTimeout_seconds_path_decl" ):
listener.exitTimeout_seconds_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTimeout_seconds_path_decl" ):
return visitor.visitTimeout_seconds_path_decl(self)
else:
return visitor.visitChildren(self)
def timeout_seconds_path_decl(self):
localctx = ASLParser.Timeout_seconds_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 66, self.RULE_timeout_seconds_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 388
self.match(ASLParser.TIMEOUTSECONDSPATH)
self.state = 389
self.match(ASLParser.COLON)
self.state = 390
self.match(ASLParser.STRINGPATH)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Heartbeat_seconds_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def HEARTBEATSECONDS(self):
return self.getToken(ASLParser.HEARTBEATSECONDS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_heartbeat_seconds_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterHeartbeat_seconds_decl" ):
listener.enterHeartbeat_seconds_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitHeartbeat_seconds_decl" ):
listener.exitHeartbeat_seconds_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitHeartbeat_seconds_decl" ):
return visitor.visitHeartbeat_seconds_decl(self)
else:
return visitor.visitChildren(self)
def heartbeat_seconds_decl(self):
localctx = ASLParser.Heartbeat_seconds_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 68, self.RULE_heartbeat_seconds_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 392
self.match(ASLParser.HEARTBEATSECONDS)
self.state = 393
self.match(ASLParser.COLON)
self.state = 394
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Heartbeat_seconds_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def HEARTBEATSECONDSPATH(self):
return self.getToken(ASLParser.HEARTBEATSECONDSPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def getRuleIndex(self):
return ASLParser.RULE_heartbeat_seconds_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterHeartbeat_seconds_path_decl" ):
listener.enterHeartbeat_seconds_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitHeartbeat_seconds_path_decl" ):
listener.exitHeartbeat_seconds_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitHeartbeat_seconds_path_decl" ):
return visitor.visitHeartbeat_seconds_path_decl(self)
else:
return visitor.visitChildren(self)
def heartbeat_seconds_path_decl(self):
localctx = ASLParser.Heartbeat_seconds_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 70, self.RULE_heartbeat_seconds_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 396
self.match(ASLParser.HEARTBEATSECONDSPATH)
self.state = 397
self.match(ASLParser.COLON)
self.state = 398
self.match(ASLParser.STRINGPATH)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Payload_tmpl_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def payload_binding(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Payload_bindingContext)
else:
return self.getTypedRuleContext(ASLParser.Payload_bindingContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_payload_tmpl_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_tmpl_decl" ):
listener.enterPayload_tmpl_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_tmpl_decl" ):
listener.exitPayload_tmpl_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_tmpl_decl" ):
return visitor.visitPayload_tmpl_decl(self)
else:
return visitor.visitChildren(self)
def payload_tmpl_decl(self):
localctx = ASLParser.Payload_tmpl_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 72, self.RULE_payload_tmpl_decl)
self._la = 0 # Token type
try:
self.state = 413
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 400
self.match(ASLParser.LBRACE)
self.state = 401
self.payload_binding()
self.state = 406
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 402
self.match(ASLParser.COMMA)
self.state = 403
self.payload_binding()
self.state = 408
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 409
self.match(ASLParser.RBRACE)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 411
self.match(ASLParser.LBRACE)
self.state = 412
self.match(ASLParser.RBRACE)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Payload_bindingContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return ASLParser.RULE_payload_binding
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class Payload_binding_pathContext(Payload_bindingContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_bindingContext
super().__init__(parser)
self.copyFrom(ctx)
def STRINGDOLLAR(self):
return self.getToken(ASLParser.STRINGDOLLAR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_binding_path" ):
listener.enterPayload_binding_path(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_binding_path" ):
listener.exitPayload_binding_path(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_binding_path" ):
return visitor.visitPayload_binding_path(self)
else:
return visitor.visitChildren(self)
class Payload_binding_path_context_objContext(Payload_bindingContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_bindingContext
super().__init__(parser)
self.copyFrom(ctx)
def STRINGDOLLAR(self):
return self.getToken(ASLParser.STRINGDOLLAR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATHCONTEXTOBJ(self):
return self.getToken(ASLParser.STRINGPATHCONTEXTOBJ, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_binding_path_context_obj" ):
listener.enterPayload_binding_path_context_obj(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_binding_path_context_obj" ):
listener.exitPayload_binding_path_context_obj(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_binding_path_context_obj" ):
return visitor.visitPayload_binding_path_context_obj(self)
else:
return visitor.visitChildren(self)
class Payload_binding_intrinsic_funcContext(Payload_bindingContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_bindingContext
super().__init__(parser)
self.copyFrom(ctx)
def STRINGDOLLAR(self):
return self.getToken(ASLParser.STRINGDOLLAR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def intrinsic_func(self):
return self.getTypedRuleContext(ASLParser.Intrinsic_funcContext,0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_binding_intrinsic_func" ):
listener.enterPayload_binding_intrinsic_func(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_binding_intrinsic_func" ):
listener.exitPayload_binding_intrinsic_func(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_binding_intrinsic_func" ):
return visitor.visitPayload_binding_intrinsic_func(self)
else:
return visitor.visitChildren(self)
class Payload_binding_valueContext(Payload_bindingContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_bindingContext
super().__init__(parser)
self.copyFrom(ctx)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def payload_value_decl(self):
return self.getTypedRuleContext(ASLParser.Payload_value_declContext,0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_binding_value" ):
listener.enterPayload_binding_value(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_binding_value" ):
listener.exitPayload_binding_value(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_binding_value" ):
return visitor.visitPayload_binding_value(self)
else:
return visitor.visitChildren(self)
def payload_binding(self):
localctx = ASLParser.Payload_bindingContext(self, self._ctx, self.state)
self.enterRule(localctx, 74, self.RULE_payload_binding)
try:
self.state = 428
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
if la_ == 1:
localctx = ASLParser.Payload_binding_pathContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 415
self.match(ASLParser.STRINGDOLLAR)
self.state = 416
self.match(ASLParser.COLON)
self.state = 417
self.match(ASLParser.STRINGPATH)
pass
elif la_ == 2:
localctx = ASLParser.Payload_binding_path_context_objContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 418
self.match(ASLParser.STRINGDOLLAR)
self.state = 419
self.match(ASLParser.COLON)
self.state = 420
self.match(ASLParser.STRINGPATHCONTEXTOBJ)
pass
elif la_ == 3:
localctx = ASLParser.Payload_binding_intrinsic_funcContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 421
self.match(ASLParser.STRINGDOLLAR)
self.state = 422
self.match(ASLParser.COLON)
self.state = 423
self.intrinsic_func()
pass
elif la_ == 4:
localctx = ASLParser.Payload_binding_valueContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 424
self.keyword_or_string()
self.state = 425
self.match(ASLParser.COLON)
self.state = 426
self.payload_value_decl()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Intrinsic_funcContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def STRING(self):
return self.getToken(ASLParser.STRING, 0)
def getRuleIndex(self):
return ASLParser.RULE_intrinsic_func
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIntrinsic_func" ):
listener.enterIntrinsic_func(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIntrinsic_func" ):
listener.exitIntrinsic_func(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIntrinsic_func" ):
return visitor.visitIntrinsic_func(self)
else:
return visitor.visitChildren(self)
def intrinsic_func(self):
localctx = ASLParser.Intrinsic_funcContext(self, self._ctx, self.state)
self.enterRule(localctx, 76, self.RULE_intrinsic_func)
try:
self.enterOuterAlt(localctx, 1)
self.state = 430
self.match(ASLParser.STRING)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Payload_arr_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def payload_value_decl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Payload_value_declContext)
else:
return self.getTypedRuleContext(ASLParser.Payload_value_declContext,i)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_payload_arr_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_arr_decl" ):
listener.enterPayload_arr_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_arr_decl" ):
listener.exitPayload_arr_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_arr_decl" ):
return visitor.visitPayload_arr_decl(self)
else:
return visitor.visitChildren(self)
def payload_arr_decl(self):
localctx = ASLParser.Payload_arr_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 78, self.RULE_payload_arr_decl)
self._la = 0 # Token type
try:
self.state = 445
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 432
self.match(ASLParser.LBRACK)
self.state = 433
self.payload_value_decl()
self.state = 438
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 434
self.match(ASLParser.COMMA)
self.state = 435
self.payload_value_decl()
self.state = 440
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 441
self.match(ASLParser.RBRACK)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 443
self.match(ASLParser.LBRACK)
self.state = 444
self.match(ASLParser.RBRACK)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Payload_value_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def payload_binding(self):
return self.getTypedRuleContext(ASLParser.Payload_bindingContext,0)
def payload_arr_decl(self):
return self.getTypedRuleContext(ASLParser.Payload_arr_declContext,0)
def payload_tmpl_decl(self):
return self.getTypedRuleContext(ASLParser.Payload_tmpl_declContext,0)
def payload_value_lit(self):
return self.getTypedRuleContext(ASLParser.Payload_value_litContext,0)
def getRuleIndex(self):
return ASLParser.RULE_payload_value_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_value_decl" ):
listener.enterPayload_value_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_value_decl" ):
listener.exitPayload_value_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_value_decl" ):
return visitor.visitPayload_value_decl(self)
else:
return visitor.visitChildren(self)
def payload_value_decl(self):
localctx = ASLParser.Payload_value_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 80, self.RULE_payload_value_decl)
try:
self.state = 451
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 447
self.payload_binding()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 448
self.payload_arr_decl()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 449
self.payload_tmpl_decl()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 450
self.payload_value_lit()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Payload_value_litContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return ASLParser.RULE_payload_value_lit
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class Payload_value_boolContext(Payload_value_litContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_value_litContext
super().__init__(parser)
self.copyFrom(ctx)
def TRUE(self):
return self.getToken(ASLParser.TRUE, 0)
def FALSE(self):
return self.getToken(ASLParser.FALSE, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_value_bool" ):
listener.enterPayload_value_bool(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_value_bool" ):
listener.exitPayload_value_bool(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_value_bool" ):
return visitor.visitPayload_value_bool(self)
else:
return visitor.visitChildren(self)
class Payload_value_intContext(Payload_value_litContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_value_litContext
super().__init__(parser)
self.copyFrom(ctx)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_value_int" ):
listener.enterPayload_value_int(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_value_int" ):
listener.exitPayload_value_int(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_value_int" ):
return visitor.visitPayload_value_int(self)
else:
return visitor.visitChildren(self)
class Payload_value_strContext(Payload_value_litContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_value_litContext
super().__init__(parser)
self.copyFrom(ctx)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_value_str" ):
listener.enterPayload_value_str(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_value_str" ):
listener.exitPayload_value_str(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_value_str" ):
return visitor.visitPayload_value_str(self)
else:
return visitor.visitChildren(self)
class Payload_value_floatContext(Payload_value_litContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_value_litContext
super().__init__(parser)
self.copyFrom(ctx)
def NUMBER(self):
return self.getToken(ASLParser.NUMBER, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_value_float" ):
listener.enterPayload_value_float(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_value_float" ):
listener.exitPayload_value_float(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_value_float" ):
return visitor.visitPayload_value_float(self)
else:
return visitor.visitChildren(self)
class Payload_value_nullContext(Payload_value_litContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Payload_value_litContext
super().__init__(parser)
self.copyFrom(ctx)
def NULL(self):
return self.getToken(ASLParser.NULL, 0)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPayload_value_null" ):
listener.enterPayload_value_null(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPayload_value_null" ):
listener.exitPayload_value_null(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPayload_value_null" ):
return visitor.visitPayload_value_null(self)
else:
return visitor.visitChildren(self)
def payload_value_lit(self):
localctx = ASLParser.Payload_value_litContext(self, self._ctx, self.state)
self.enterRule(localctx, 82, self.RULE_payload_value_lit)
self._la = 0 # Token type
try:
self.state = 458
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [140]:
localctx = ASLParser.Payload_value_floatContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 453
self.match(ASLParser.NUMBER)
pass
elif token in [139]:
localctx = ASLParser.Payload_value_intContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 454
self.match(ASLParser.INT)
pass
elif token in [7, 8]:
localctx = ASLParser.Payload_value_boolContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 455
_la = self._input.LA(1)
if not(_la==7 or _la==8):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif token in [9]:
localctx = ASLParser.Payload_value_nullContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 456
self.match(ASLParser.NULL)
pass
elif token in [10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138]:
localctx = ASLParser.Payload_value_strContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 457
self.keyword_or_string()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Result_selector_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def RESULTSELECTOR(self):
return self.getToken(ASLParser.RESULTSELECTOR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def payload_tmpl_decl(self):
return self.getTypedRuleContext(ASLParser.Payload_tmpl_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_result_selector_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterResult_selector_decl" ):
listener.enterResult_selector_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitResult_selector_decl" ):
listener.exitResult_selector_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitResult_selector_decl" ):
return visitor.visitResult_selector_decl(self)
else:
return visitor.visitChildren(self)
def result_selector_decl(self):
localctx = ASLParser.Result_selector_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 84, self.RULE_result_selector_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 460
self.match(ASLParser.RESULTSELECTOR)
self.state = 461
self.match(ASLParser.COLON)
self.state = 462
self.payload_tmpl_decl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class State_typeContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def TASK(self):
return self.getToken(ASLParser.TASK, 0)
def PASS(self):
return self.getToken(ASLParser.PASS, 0)
def CHOICE(self):
return self.getToken(ASLParser.CHOICE, 0)
def FAIL(self):
return self.getToken(ASLParser.FAIL, 0)
def SUCCEED(self):
return self.getToken(ASLParser.SUCCEED, 0)
def WAIT(self):
return self.getToken(ASLParser.WAIT, 0)
def MAP(self):
return self.getToken(ASLParser.MAP, 0)
def PARALLEL(self):
return self.getToken(ASLParser.PARALLEL, 0)
def getRuleIndex(self):
return ASLParser.RULE_state_type
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterState_type" ):
listener.enterState_type(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitState_type" ):
listener.exitState_type(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitState_type" ):
return visitor.visitState_type(self)
else:
return visitor.visitChildren(self)
def state_type(self):
localctx = ASLParser.State_typeContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_state_type)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 464
_la = self._input.LA(1)
if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 16711680) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Choices_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def CHOICES(self):
return self.getToken(ASLParser.CHOICES, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def choice_rule(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Choice_ruleContext)
else:
return self.getTypedRuleContext(ASLParser.Choice_ruleContext,i)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_choices_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterChoices_decl" ):
listener.enterChoices_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitChoices_decl" ):
listener.exitChoices_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitChoices_decl" ):
return visitor.visitChoices_decl(self)
else:
return visitor.visitChildren(self)
def choices_decl(self):
localctx = ASLParser.Choices_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 88, self.RULE_choices_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 466
self.match(ASLParser.CHOICES)
self.state = 467
self.match(ASLParser.COLON)
self.state = 468
self.match(ASLParser.LBRACK)
self.state = 469
self.choice_rule()
self.state = 474
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 470
self.match(ASLParser.COMMA)
self.state = 471
self.choice_rule()
self.state = 476
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 477
self.match(ASLParser.RBRACK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Choice_ruleContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return ASLParser.RULE_choice_rule
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class Choice_rule_comparison_variableContext(Choice_ruleContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Choice_ruleContext
super().__init__(parser)
self.copyFrom(ctx)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def comparison_variable_stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Comparison_variable_stmtContext)
else:
return self.getTypedRuleContext(ASLParser.Comparison_variable_stmtContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterChoice_rule_comparison_variable" ):
listener.enterChoice_rule_comparison_variable(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitChoice_rule_comparison_variable" ):
listener.exitChoice_rule_comparison_variable(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitChoice_rule_comparison_variable" ):
return visitor.visitChoice_rule_comparison_variable(self)
else:
return visitor.visitChildren(self)
class Choice_rule_comparison_compositeContext(Choice_ruleContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a ASLParser.Choice_ruleContext
super().__init__(parser)
self.copyFrom(ctx)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def comparison_composite_stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Comparison_composite_stmtContext)
else:
return self.getTypedRuleContext(ASLParser.Comparison_composite_stmtContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterChoice_rule_comparison_composite" ):
listener.enterChoice_rule_comparison_composite(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitChoice_rule_comparison_composite" ):
listener.exitChoice_rule_comparison_composite(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitChoice_rule_comparison_composite" ):
return visitor.visitChoice_rule_comparison_composite(self)
else:
return visitor.visitChildren(self)
def choice_rule(self):
localctx = ASLParser.Choice_ruleContext(self, self._ctx, self.state)
self.enterRule(localctx, 90, self.RULE_choice_rule)
self._la = 0 # Token type
try:
self.state = 500
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
if la_ == 1:
localctx = ASLParser.Choice_rule_comparison_variableContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 479
self.match(ASLParser.LBRACE)
self.state = 480
self.comparison_variable_stmt()
self.state = 483
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 481
self.match(ASLParser.COMMA)
self.state = 482
self.comparison_variable_stmt()
self.state = 485
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==1):
break
self.state = 487
self.match(ASLParser.RBRACE)
pass
elif la_ == 2:
localctx = ASLParser.Choice_rule_comparison_compositeContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 489
self.match(ASLParser.LBRACE)
self.state = 490
self.comparison_composite_stmt()
self.state = 495
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 491
self.match(ASLParser.COMMA)
self.state = 492
self.comparison_composite_stmt()
self.state = 497
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 498
self.match(ASLParser.RBRACE)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Comparison_variable_stmtContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def variable_decl(self):
return self.getTypedRuleContext(ASLParser.Variable_declContext,0)
def comparison_func(self):
return self.getTypedRuleContext(ASLParser.Comparison_funcContext,0)
def next_decl(self):
return self.getTypedRuleContext(ASLParser.Next_declContext,0)
def comment_decl(self):
return self.getTypedRuleContext(ASLParser.Comment_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_comparison_variable_stmt
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComparison_variable_stmt" ):
listener.enterComparison_variable_stmt(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComparison_variable_stmt" ):
listener.exitComparison_variable_stmt(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComparison_variable_stmt" ):
return visitor.visitComparison_variable_stmt(self)
else:
return visitor.visitChildren(self)
def comparison_variable_stmt(self):
localctx = ASLParser.Comparison_variable_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 92, self.RULE_comparison_variable_stmt)
try:
self.state = 506
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [25]:
self.enterOuterAlt(localctx, 1)
self.state = 502
self.variable_decl()
pass
elif token in [29, 30, 31, 32, 33, 34, 35, 36, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69]:
self.enterOuterAlt(localctx, 2)
self.state = 503
self.comparison_func()
pass
elif token in [104]:
self.enterOuterAlt(localctx, 3)
self.state = 504
self.next_decl()
pass
elif token in [10]:
self.enterOuterAlt(localctx, 4)
self.state = 505
self.comment_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Comparison_composite_stmtContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def comparison_composite(self):
return self.getTypedRuleContext(ASLParser.Comparison_compositeContext,0)
def next_decl(self):
return self.getTypedRuleContext(ASLParser.Next_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_comparison_composite_stmt
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComparison_composite_stmt" ):
listener.enterComparison_composite_stmt(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComparison_composite_stmt" ):
listener.exitComparison_composite_stmt(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComparison_composite_stmt" ):
return visitor.visitComparison_composite_stmt(self)
else:
return visitor.visitChildren(self)
def comparison_composite_stmt(self):
localctx = ASLParser.Comparison_composite_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 94, self.RULE_comparison_composite_stmt)
try:
self.state = 510
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [28, 37, 48]:
self.enterOuterAlt(localctx, 1)
self.state = 508
self.comparison_composite()
pass
elif token in [104]:
self.enterOuterAlt(localctx, 2)
self.state = 509
self.next_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Comparison_compositeContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def choice_operator(self):
return self.getTypedRuleContext(ASLParser.Choice_operatorContext,0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def choice_rule(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Choice_ruleContext)
else:
return self.getTypedRuleContext(ASLParser.Choice_ruleContext,i)
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_comparison_composite
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComparison_composite" ):
listener.enterComparison_composite(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComparison_composite" ):
listener.exitComparison_composite(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComparison_composite" ):
return visitor.visitComparison_composite(self)
else:
return visitor.visitChildren(self)
def comparison_composite(self):
localctx = ASLParser.Comparison_compositeContext(self, self._ctx, self.state)
self.enterRule(localctx, 96, self.RULE_comparison_composite)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 512
self.choice_operator()
self.state = 513
self.match(ASLParser.COLON)
self.state = 526
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [5]:
self.state = 514
self.choice_rule()
pass
elif token in [3]:
self.state = 515
self.match(ASLParser.LBRACK)
self.state = 516
self.choice_rule()
self.state = 521
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 517
self.match(ASLParser.COMMA)
self.state = 518
self.choice_rule()
self.state = 523
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 524
self.match(ASLParser.RBRACK)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Variable_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def VARIABLE(self):
return self.getToken(ASLParser.VARIABLE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_variable_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVariable_decl" ):
listener.enterVariable_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVariable_decl" ):
listener.exitVariable_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVariable_decl" ):
return visitor.visitVariable_decl(self)
else:
return visitor.visitChildren(self)
def variable_decl(self):
localctx = ASLParser.Variable_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_variable_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 528
self.match(ASLParser.VARIABLE)
self.state = 529
self.match(ASLParser.COLON)
self.state = 530
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Comparison_funcContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def comparison_op(self):
return self.getTypedRuleContext(ASLParser.Comparison_opContext,0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def json_value_decl(self):
return self.getTypedRuleContext(ASLParser.Json_value_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_comparison_func
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComparison_func" ):
listener.enterComparison_func(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComparison_func" ):
listener.exitComparison_func(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComparison_func" ):
return visitor.visitComparison_func(self)
else:
return visitor.visitChildren(self)
def comparison_func(self):
localctx = ASLParser.Comparison_funcContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_comparison_func)
try:
self.enterOuterAlt(localctx, 1)
self.state = 532
self.comparison_op()
self.state = 533
self.match(ASLParser.COLON)
self.state = 534
self.json_value_decl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Branches_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def BRANCHES(self):
return self.getToken(ASLParser.BRANCHES, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def program_decl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Program_declContext)
else:
return self.getTypedRuleContext(ASLParser.Program_declContext,i)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_branches_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBranches_decl" ):
listener.enterBranches_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBranches_decl" ):
listener.exitBranches_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBranches_decl" ):
return visitor.visitBranches_decl(self)
else:
return visitor.visitChildren(self)
def branches_decl(self):
localctx = ASLParser.Branches_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 102, self.RULE_branches_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 536
self.match(ASLParser.BRANCHES)
self.state = 537
self.match(ASLParser.COLON)
self.state = 538
self.match(ASLParser.LBRACK)
self.state = 539
self.program_decl()
self.state = 544
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 540
self.match(ASLParser.COMMA)
self.state = 541
self.program_decl()
self.state = 546
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 547
self.match(ASLParser.RBRACK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Item_processor_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ITEMPROCESSOR(self):
return self.getToken(ASLParser.ITEMPROCESSOR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def item_processor_item(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Item_processor_itemContext)
else:
return self.getTypedRuleContext(ASLParser.Item_processor_itemContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_item_processor_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterItem_processor_decl" ):
listener.enterItem_processor_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitItem_processor_decl" ):
listener.exitItem_processor_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitItem_processor_decl" ):
return visitor.visitItem_processor_decl(self)
else:
return visitor.visitChildren(self)
def item_processor_decl(self):
localctx = ASLParser.Item_processor_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 104, self.RULE_item_processor_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 549
self.match(ASLParser.ITEMPROCESSOR)
self.state = 550
self.match(ASLParser.COLON)
self.state = 551
self.match(ASLParser.LBRACE)
self.state = 552
self.item_processor_item()
self.state = 557
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 553
self.match(ASLParser.COMMA)
self.state = 554
self.item_processor_item()
self.state = 559
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 560
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Item_processor_itemContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def processor_config_decl(self):
return self.getTypedRuleContext(ASLParser.Processor_config_declContext,0)
def startat_decl(self):
return self.getTypedRuleContext(ASLParser.Startat_declContext,0)
def states_decl(self):
return self.getTypedRuleContext(ASLParser.States_declContext,0)
def comment_decl(self):
return self.getTypedRuleContext(ASLParser.Comment_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_item_processor_item
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterItem_processor_item" ):
listener.enterItem_processor_item(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitItem_processor_item" ):
listener.exitItem_processor_item(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitItem_processor_item" ):
return visitor.visitItem_processor_item(self)
else:
return visitor.visitChildren(self)
def item_processor_item(self):
localctx = ASLParser.Item_processor_itemContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_item_processor_item)
try:
self.state = 566
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [78]:
self.enterOuterAlt(localctx, 1)
self.state = 562
self.processor_config_decl()
pass
elif token in [12]:
self.enterOuterAlt(localctx, 2)
self.state = 563
self.startat_decl()
pass
elif token in [11]:
self.enterOuterAlt(localctx, 3)
self.state = 564
self.states_decl()
pass
elif token in [10]:
self.enterOuterAlt(localctx, 4)
self.state = 565
self.comment_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Processor_config_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def PROCESSORCONFIG(self):
return self.getToken(ASLParser.PROCESSORCONFIG, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def processor_config_field(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Processor_config_fieldContext)
else:
return self.getTypedRuleContext(ASLParser.Processor_config_fieldContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_processor_config_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProcessor_config_decl" ):
listener.enterProcessor_config_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProcessor_config_decl" ):
listener.exitProcessor_config_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProcessor_config_decl" ):
return visitor.visitProcessor_config_decl(self)
else:
return visitor.visitChildren(self)
def processor_config_decl(self):
localctx = ASLParser.Processor_config_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 108, self.RULE_processor_config_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 568
self.match(ASLParser.PROCESSORCONFIG)
self.state = 569
self.match(ASLParser.COLON)
self.state = 570
self.match(ASLParser.LBRACE)
self.state = 571
self.processor_config_field()
self.state = 576
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 572
self.match(ASLParser.COMMA)
self.state = 573
self.processor_config_field()
self.state = 578
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 579
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Processor_config_fieldContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def mode_decl(self):
return self.getTypedRuleContext(ASLParser.Mode_declContext,0)
def execution_decl(self):
return self.getTypedRuleContext(ASLParser.Execution_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_processor_config_field
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterProcessor_config_field" ):
listener.enterProcessor_config_field(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitProcessor_config_field" ):
listener.exitProcessor_config_field(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitProcessor_config_field" ):
return visitor.visitProcessor_config_field(self)
else:
return visitor.visitChildren(self)
def processor_config_field(self):
localctx = ASLParser.Processor_config_fieldContext(self, self._ctx, self.state)
self.enterRule(localctx, 110, self.RULE_processor_config_field)
try:
self.state = 583
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [79]:
self.enterOuterAlt(localctx, 1)
self.state = 581
self.mode_decl()
pass
elif token in [82]:
self.enterOuterAlt(localctx, 2)
self.state = 582
self.execution_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Mode_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def MODE(self):
return self.getToken(ASLParser.MODE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def mode_type(self):
return self.getTypedRuleContext(ASLParser.Mode_typeContext,0)
def getRuleIndex(self):
return ASLParser.RULE_mode_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMode_decl" ):
listener.enterMode_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMode_decl" ):
listener.exitMode_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMode_decl" ):
return visitor.visitMode_decl(self)
else:
return visitor.visitChildren(self)
def mode_decl(self):
localctx = ASLParser.Mode_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_mode_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 585
self.match(ASLParser.MODE)
self.state = 586
self.match(ASLParser.COLON)
self.state = 587
self.mode_type()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Mode_typeContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def INLINE(self):
return self.getToken(ASLParser.INLINE, 0)
def DISTRIBUTED(self):
return self.getToken(ASLParser.DISTRIBUTED, 0)
def getRuleIndex(self):
return ASLParser.RULE_mode_type
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMode_type" ):
listener.enterMode_type(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMode_type" ):
listener.exitMode_type(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMode_type" ):
return visitor.visitMode_type(self)
else:
return visitor.visitChildren(self)
def mode_type(self):
localctx = ASLParser.Mode_typeContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_mode_type)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 589
_la = self._input.LA(1)
if not(_la==80 or _la==81):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Execution_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def EXECUTIONTYPE(self):
return self.getToken(ASLParser.EXECUTIONTYPE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def execution_type(self):
return self.getTypedRuleContext(ASLParser.Execution_typeContext,0)
def getRuleIndex(self):
return ASLParser.RULE_execution_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExecution_decl" ):
listener.enterExecution_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExecution_decl" ):
listener.exitExecution_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExecution_decl" ):
return visitor.visitExecution_decl(self)
else:
return visitor.visitChildren(self)
def execution_decl(self):
localctx = ASLParser.Execution_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_execution_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 591
self.match(ASLParser.EXECUTIONTYPE)
self.state = 592
self.match(ASLParser.COLON)
self.state = 593
self.execution_type()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Execution_typeContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def STANDARD(self):
return self.getToken(ASLParser.STANDARD, 0)
def getRuleIndex(self):
return ASLParser.RULE_execution_type
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExecution_type" ):
listener.enterExecution_type(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExecution_type" ):
listener.exitExecution_type(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExecution_type" ):
return visitor.visitExecution_type(self)
else:
return visitor.visitChildren(self)
def execution_type(self):
localctx = ASLParser.Execution_typeContext(self, self._ctx, self.state)
self.enterRule(localctx, 118, self.RULE_execution_type)
try:
self.enterOuterAlt(localctx, 1)
self.state = 595
self.match(ASLParser.STANDARD)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Iterator_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ITERATOR(self):
return self.getToken(ASLParser.ITERATOR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def iterator_decl_item(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Iterator_decl_itemContext)
else:
return self.getTypedRuleContext(ASLParser.Iterator_decl_itemContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_iterator_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIterator_decl" ):
listener.enterIterator_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIterator_decl" ):
listener.exitIterator_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIterator_decl" ):
return visitor.visitIterator_decl(self)
else:
return visitor.visitChildren(self)
def iterator_decl(self):
localctx = ASLParser.Iterator_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 120, self.RULE_iterator_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 597
self.match(ASLParser.ITERATOR)
self.state = 598
self.match(ASLParser.COLON)
self.state = 599
self.match(ASLParser.LBRACE)
self.state = 600
self.iterator_decl_item()
self.state = 605
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 601
self.match(ASLParser.COMMA)
self.state = 602
self.iterator_decl_item()
self.state = 607
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 608
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Iterator_decl_itemContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def startat_decl(self):
return self.getTypedRuleContext(ASLParser.Startat_declContext,0)
def states_decl(self):
return self.getTypedRuleContext(ASLParser.States_declContext,0)
def comment_decl(self):
return self.getTypedRuleContext(ASLParser.Comment_declContext,0)
def processor_config_decl(self):
return self.getTypedRuleContext(ASLParser.Processor_config_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_iterator_decl_item
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIterator_decl_item" ):
listener.enterIterator_decl_item(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIterator_decl_item" ):
listener.exitIterator_decl_item(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIterator_decl_item" ):
return visitor.visitIterator_decl_item(self)
else:
return visitor.visitChildren(self)
def iterator_decl_item(self):
localctx = ASLParser.Iterator_decl_itemContext(self, self._ctx, self.state)
self.enterRule(localctx, 122, self.RULE_iterator_decl_item)
try:
self.state = 614
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [12]:
self.enterOuterAlt(localctx, 1)
self.state = 610
self.startat_decl()
pass
elif token in [11]:
self.enterOuterAlt(localctx, 2)
self.state = 611
self.states_decl()
pass
elif token in [10]:
self.enterOuterAlt(localctx, 3)
self.state = 612
self.comment_decl()
pass
elif token in [78]:
self.enterOuterAlt(localctx, 4)
self.state = 613
self.processor_config_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Item_selector_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ITEMSELECTOR(self):
return self.getToken(ASLParser.ITEMSELECTOR, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def payload_tmpl_decl(self):
return self.getTypedRuleContext(ASLParser.Payload_tmpl_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_item_selector_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterItem_selector_decl" ):
listener.enterItem_selector_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitItem_selector_decl" ):
listener.exitItem_selector_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitItem_selector_decl" ):
return visitor.visitItem_selector_decl(self)
else:
return visitor.visitChildren(self)
def item_selector_decl(self):
localctx = ASLParser.Item_selector_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 124, self.RULE_item_selector_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 616
self.match(ASLParser.ITEMSELECTOR)
self.state = 617
self.match(ASLParser.COLON)
self.state = 618
self.payload_tmpl_decl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Item_reader_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ITEMREADER(self):
return self.getToken(ASLParser.ITEMREADER, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def items_reader_field(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Items_reader_fieldContext)
else:
return self.getTypedRuleContext(ASLParser.Items_reader_fieldContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_item_reader_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterItem_reader_decl" ):
listener.enterItem_reader_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitItem_reader_decl" ):
listener.exitItem_reader_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitItem_reader_decl" ):
return visitor.visitItem_reader_decl(self)
else:
return visitor.visitChildren(self)
def item_reader_decl(self):
localctx = ASLParser.Item_reader_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 126, self.RULE_item_reader_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 620
self.match(ASLParser.ITEMREADER)
self.state = 621
self.match(ASLParser.COLON)
self.state = 622
self.match(ASLParser.LBRACE)
self.state = 623
self.items_reader_field()
self.state = 628
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 624
self.match(ASLParser.COMMA)
self.state = 625
self.items_reader_field()
self.state = 630
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 631
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Items_reader_fieldContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def resource_decl(self):
return self.getTypedRuleContext(ASLParser.Resource_declContext,0)
def parameters_decl(self):
return self.getTypedRuleContext(ASLParser.Parameters_declContext,0)
def reader_config_decl(self):
return self.getTypedRuleContext(ASLParser.Reader_config_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_items_reader_field
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterItems_reader_field" ):
listener.enterItems_reader_field(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitItems_reader_field" ):
listener.exitItems_reader_field(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitItems_reader_field" ):
return visitor.visitItems_reader_field(self)
else:
return visitor.visitChildren(self)
def items_reader_field(self):
localctx = ASLParser.Items_reader_fieldContext(self, self._ctx, self.state)
self.enterRule(localctx, 128, self.RULE_items_reader_field)
try:
self.state = 636
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [89]:
self.enterOuterAlt(localctx, 1)
self.state = 633
self.resource_decl()
pass
elif token in [95]:
self.enterOuterAlt(localctx, 2)
self.state = 634
self.parameters_decl()
pass
elif token in [98]:
self.enterOuterAlt(localctx, 3)
self.state = 635
self.reader_config_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Reader_config_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def READERCONFIG(self):
return self.getToken(ASLParser.READERCONFIG, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def reader_config_field(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Reader_config_fieldContext)
else:
return self.getTypedRuleContext(ASLParser.Reader_config_fieldContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_reader_config_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterReader_config_decl" ):
listener.enterReader_config_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitReader_config_decl" ):
listener.exitReader_config_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReader_config_decl" ):
return visitor.visitReader_config_decl(self)
else:
return visitor.visitChildren(self)
def reader_config_decl(self):
localctx = ASLParser.Reader_config_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 130, self.RULE_reader_config_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 638
self.match(ASLParser.READERCONFIG)
self.state = 639
self.match(ASLParser.COLON)
self.state = 640
self.match(ASLParser.LBRACE)
self.state = 641
self.reader_config_field()
self.state = 646
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 642
self.match(ASLParser.COMMA)
self.state = 643
self.reader_config_field()
self.state = 648
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 649
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Reader_config_fieldContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def input_type_decl(self):
return self.getTypedRuleContext(ASLParser.Input_type_declContext,0)
def csv_header_location_decl(self):
return self.getTypedRuleContext(ASLParser.Csv_header_location_declContext,0)
def csv_headers_decl(self):
return self.getTypedRuleContext(ASLParser.Csv_headers_declContext,0)
def max_items_decl(self):
return self.getTypedRuleContext(ASLParser.Max_items_declContext,0)
def max_items_path_decl(self):
return self.getTypedRuleContext(ASLParser.Max_items_path_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_reader_config_field
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterReader_config_field" ):
listener.enterReader_config_field(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitReader_config_field" ):
listener.exitReader_config_field(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReader_config_field" ):
return visitor.visitReader_config_field(self)
else:
return visitor.visitChildren(self)
def reader_config_field(self):
localctx = ASLParser.Reader_config_fieldContext(self, self._ctx, self.state)
self.enterRule(localctx, 132, self.RULE_reader_config_field)
try:
self.state = 656
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [99]:
self.enterOuterAlt(localctx, 1)
self.state = 651
self.input_type_decl()
pass
elif token in [100]:
self.enterOuterAlt(localctx, 2)
self.state = 652
self.csv_header_location_decl()
pass
elif token in [101]:
self.enterOuterAlt(localctx, 3)
self.state = 653
self.csv_headers_decl()
pass
elif token in [102]:
self.enterOuterAlt(localctx, 4)
self.state = 654
self.max_items_decl()
pass
elif token in [103]:
self.enterOuterAlt(localctx, 5)
self.state = 655
self.max_items_path_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Input_type_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def INPUTTYPE(self):
return self.getToken(ASLParser.INPUTTYPE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_input_type_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInput_type_decl" ):
listener.enterInput_type_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInput_type_decl" ):
listener.exitInput_type_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInput_type_decl" ):
return visitor.visitInput_type_decl(self)
else:
return visitor.visitChildren(self)
def input_type_decl(self):
localctx = ASLParser.Input_type_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 134, self.RULE_input_type_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 658
self.match(ASLParser.INPUTTYPE)
self.state = 659
self.match(ASLParser.COLON)
self.state = 660
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Csv_header_location_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def CSVHEADERLOCATION(self):
return self.getToken(ASLParser.CSVHEADERLOCATION, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_csv_header_location_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCsv_header_location_decl" ):
listener.enterCsv_header_location_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCsv_header_location_decl" ):
listener.exitCsv_header_location_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCsv_header_location_decl" ):
return visitor.visitCsv_header_location_decl(self)
else:
return visitor.visitChildren(self)
def csv_header_location_decl(self):
localctx = ASLParser.Csv_header_location_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 136, self.RULE_csv_header_location_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 662
self.match(ASLParser.CSVHEADERLOCATION)
self.state = 663
self.match(ASLParser.COLON)
self.state = 664
self.keyword_or_string()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Csv_headers_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def CSVHEADERS(self):
return self.getToken(ASLParser.CSVHEADERS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def keyword_or_string(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Keyword_or_stringContext)
else:
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,i)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_csv_headers_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCsv_headers_decl" ):
listener.enterCsv_headers_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCsv_headers_decl" ):
listener.exitCsv_headers_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCsv_headers_decl" ):
return visitor.visitCsv_headers_decl(self)
else:
return visitor.visitChildren(self)
def csv_headers_decl(self):
localctx = ASLParser.Csv_headers_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 138, self.RULE_csv_headers_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 666
self.match(ASLParser.CSVHEADERS)
self.state = 667
self.match(ASLParser.COLON)
self.state = 668
self.match(ASLParser.LBRACK)
self.state = 669
self.keyword_or_string()
self.state = 674
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 670
self.match(ASLParser.COMMA)
self.state = 671
self.keyword_or_string()
self.state = 676
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 677
self.match(ASLParser.RBRACK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Max_items_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def MAXITEMS(self):
return self.getToken(ASLParser.MAXITEMS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_max_items_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMax_items_decl" ):
listener.enterMax_items_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMax_items_decl" ):
listener.exitMax_items_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMax_items_decl" ):
return visitor.visitMax_items_decl(self)
else:
return visitor.visitChildren(self)
def max_items_decl(self):
localctx = ASLParser.Max_items_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 140, self.RULE_max_items_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 679
self.match(ASLParser.MAXITEMS)
self.state = 680
self.match(ASLParser.COLON)
self.state = 681
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Max_items_path_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def MAXITEMSPATH(self):
return self.getToken(ASLParser.MAXITEMSPATH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def getRuleIndex(self):
return ASLParser.RULE_max_items_path_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMax_items_path_decl" ):
listener.enterMax_items_path_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMax_items_path_decl" ):
listener.exitMax_items_path_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMax_items_path_decl" ):
return visitor.visitMax_items_path_decl(self)
else:
return visitor.visitChildren(self)
def max_items_path_decl(self):
localctx = ASLParser.Max_items_path_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 142, self.RULE_max_items_path_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 683
self.match(ASLParser.MAXITEMSPATH)
self.state = 684
self.match(ASLParser.COLON)
self.state = 685
self.match(ASLParser.STRINGPATH)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Retry_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def RETRY(self):
return self.getToken(ASLParser.RETRY, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def retrier_decl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Retrier_declContext)
else:
return self.getTypedRuleContext(ASLParser.Retrier_declContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_retry_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRetry_decl" ):
listener.enterRetry_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRetry_decl" ):
listener.exitRetry_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRetry_decl" ):
return visitor.visitRetry_decl(self)
else:
return visitor.visitChildren(self)
def retry_decl(self):
localctx = ASLParser.Retry_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 144, self.RULE_retry_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 687
self.match(ASLParser.RETRY)
self.state = 688
self.match(ASLParser.COLON)
self.state = 689
self.match(ASLParser.LBRACK)
self.state = 698
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==5:
self.state = 690
self.retrier_decl()
self.state = 695
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 691
self.match(ASLParser.COMMA)
self.state = 692
self.retrier_decl()
self.state = 697
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 700
self.match(ASLParser.RBRACK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Retrier_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def retrier_stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Retrier_stmtContext)
else:
return self.getTypedRuleContext(ASLParser.Retrier_stmtContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_retrier_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRetrier_decl" ):
listener.enterRetrier_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRetrier_decl" ):
listener.exitRetrier_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRetrier_decl" ):
return visitor.visitRetrier_decl(self)
else:
return visitor.visitChildren(self)
def retrier_decl(self):
localctx = ASLParser.Retrier_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 146, self.RULE_retrier_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 702
self.match(ASLParser.LBRACE)
self.state = 703
self.retrier_stmt()
self.state = 708
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 704
self.match(ASLParser.COMMA)
self.state = 705
self.retrier_stmt()
self.state = 710
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 711
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Retrier_stmtContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def error_equals_decl(self):
return self.getTypedRuleContext(ASLParser.Error_equals_declContext,0)
def interval_seconds_decl(self):
return self.getTypedRuleContext(ASLParser.Interval_seconds_declContext,0)
def max_attempts_decl(self):
return self.getTypedRuleContext(ASLParser.Max_attempts_declContext,0)
def backoff_rate_decl(self):
return self.getTypedRuleContext(ASLParser.Backoff_rate_declContext,0)
def max_delay_seconds_decl(self):
return self.getTypedRuleContext(ASLParser.Max_delay_seconds_declContext,0)
def jitter_strategy_decl(self):
return self.getTypedRuleContext(ASLParser.Jitter_strategy_declContext,0)
def comment_decl(self):
return self.getTypedRuleContext(ASLParser.Comment_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_retrier_stmt
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRetrier_stmt" ):
listener.enterRetrier_stmt(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRetrier_stmt" ):
listener.exitRetrier_stmt(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRetrier_stmt" ):
return visitor.visitRetrier_stmt(self)
else:
return visitor.visitChildren(self)
def retrier_stmt(self):
localctx = ASLParser.Retrier_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 148, self.RULE_retrier_stmt)
try:
self.state = 720
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [111]:
self.enterOuterAlt(localctx, 1)
self.state = 713
self.error_equals_decl()
pass
elif token in [112]:
self.enterOuterAlt(localctx, 2)
self.state = 714
self.interval_seconds_decl()
pass
elif token in [113]:
self.enterOuterAlt(localctx, 3)
self.state = 715
self.max_attempts_decl()
pass
elif token in [114]:
self.enterOuterAlt(localctx, 4)
self.state = 716
self.backoff_rate_decl()
pass
elif token in [115]:
self.enterOuterAlt(localctx, 5)
self.state = 717
self.max_delay_seconds_decl()
pass
elif token in [116]:
self.enterOuterAlt(localctx, 6)
self.state = 718
self.jitter_strategy_decl()
pass
elif token in [10]:
self.enterOuterAlt(localctx, 7)
self.state = 719
self.comment_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Error_equals_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ERROREQUALS(self):
return self.getToken(ASLParser.ERROREQUALS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def error_name(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Error_nameContext)
else:
return self.getTypedRuleContext(ASLParser.Error_nameContext,i)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_error_equals_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterError_equals_decl" ):
listener.enterError_equals_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitError_equals_decl" ):
listener.exitError_equals_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitError_equals_decl" ):
return visitor.visitError_equals_decl(self)
else:
return visitor.visitChildren(self)
def error_equals_decl(self):
localctx = ASLParser.Error_equals_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 150, self.RULE_error_equals_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 722
self.match(ASLParser.ERROREQUALS)
self.state = 723
self.match(ASLParser.COLON)
self.state = 724
self.match(ASLParser.LBRACK)
self.state = 725
self.error_name()
self.state = 730
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 726
self.match(ASLParser.COMMA)
self.state = 727
self.error_name()
self.state = 732
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 733
self.match(ASLParser.RBRACK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Interval_seconds_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def INTERVALSECONDS(self):
return self.getToken(ASLParser.INTERVALSECONDS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_interval_seconds_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInterval_seconds_decl" ):
listener.enterInterval_seconds_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInterval_seconds_decl" ):
listener.exitInterval_seconds_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInterval_seconds_decl" ):
return visitor.visitInterval_seconds_decl(self)
else:
return visitor.visitChildren(self)
def interval_seconds_decl(self):
localctx = ASLParser.Interval_seconds_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 152, self.RULE_interval_seconds_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 735
self.match(ASLParser.INTERVALSECONDS)
self.state = 736
self.match(ASLParser.COLON)
self.state = 737
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Max_attempts_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def MAXATTEMPTS(self):
return self.getToken(ASLParser.MAXATTEMPTS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_max_attempts_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMax_attempts_decl" ):
listener.enterMax_attempts_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMax_attempts_decl" ):
listener.exitMax_attempts_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMax_attempts_decl" ):
return visitor.visitMax_attempts_decl(self)
else:
return visitor.visitChildren(self)
def max_attempts_decl(self):
localctx = ASLParser.Max_attempts_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 154, self.RULE_max_attempts_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 739
self.match(ASLParser.MAXATTEMPTS)
self.state = 740
self.match(ASLParser.COLON)
self.state = 741
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Backoff_rate_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def BACKOFFRATE(self):
return self.getToken(ASLParser.BACKOFFRATE, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def NUMBER(self):
return self.getToken(ASLParser.NUMBER, 0)
def getRuleIndex(self):
return ASLParser.RULE_backoff_rate_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBackoff_rate_decl" ):
listener.enterBackoff_rate_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBackoff_rate_decl" ):
listener.exitBackoff_rate_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBackoff_rate_decl" ):
return visitor.visitBackoff_rate_decl(self)
else:
return visitor.visitChildren(self)
def backoff_rate_decl(self):
localctx = ASLParser.Backoff_rate_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 156, self.RULE_backoff_rate_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 743
self.match(ASLParser.BACKOFFRATE)
self.state = 744
self.match(ASLParser.COLON)
self.state = 745
_la = self._input.LA(1)
if not(_la==139 or _la==140):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Max_delay_seconds_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def MAXDELAYSECONDS(self):
return self.getToken(ASLParser.MAXDELAYSECONDS, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def getRuleIndex(self):
return ASLParser.RULE_max_delay_seconds_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterMax_delay_seconds_decl" ):
listener.enterMax_delay_seconds_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitMax_delay_seconds_decl" ):
listener.exitMax_delay_seconds_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitMax_delay_seconds_decl" ):
return visitor.visitMax_delay_seconds_decl(self)
else:
return visitor.visitChildren(self)
def max_delay_seconds_decl(self):
localctx = ASLParser.Max_delay_seconds_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 158, self.RULE_max_delay_seconds_decl)
try:
self.enterOuterAlt(localctx, 1)
self.state = 747
self.match(ASLParser.MAXDELAYSECONDS)
self.state = 748
self.match(ASLParser.COLON)
self.state = 749
self.match(ASLParser.INT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Jitter_strategy_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def JITTERSTRATEGY(self):
return self.getToken(ASLParser.JITTERSTRATEGY, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def FULL(self):
return self.getToken(ASLParser.FULL, 0)
def NONE(self):
return self.getToken(ASLParser.NONE, 0)
def getRuleIndex(self):
return ASLParser.RULE_jitter_strategy_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterJitter_strategy_decl" ):
listener.enterJitter_strategy_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitJitter_strategy_decl" ):
listener.exitJitter_strategy_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitJitter_strategy_decl" ):
return visitor.visitJitter_strategy_decl(self)
else:
return visitor.visitChildren(self)
def jitter_strategy_decl(self):
localctx = ASLParser.Jitter_strategy_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 160, self.RULE_jitter_strategy_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 751
self.match(ASLParser.JITTERSTRATEGY)
self.state = 752
self.match(ASLParser.COLON)
self.state = 753
_la = self._input.LA(1)
if not(_la==117 or _la==118):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Catch_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def CATCH(self):
return self.getToken(ASLParser.CATCH, 0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def catcher_decl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Catcher_declContext)
else:
return self.getTypedRuleContext(ASLParser.Catcher_declContext,i)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_catch_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCatch_decl" ):
listener.enterCatch_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCatch_decl" ):
listener.exitCatch_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCatch_decl" ):
return visitor.visitCatch_decl(self)
else:
return visitor.visitChildren(self)
def catch_decl(self):
localctx = ASLParser.Catch_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 162, self.RULE_catch_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 755
self.match(ASLParser.CATCH)
self.state = 756
self.match(ASLParser.COLON)
self.state = 757
self.match(ASLParser.LBRACK)
self.state = 766
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==5:
self.state = 758
self.catcher_decl()
self.state = 763
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 759
self.match(ASLParser.COMMA)
self.state = 760
self.catcher_decl()
self.state = 765
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 768
self.match(ASLParser.RBRACK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Catcher_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def catcher_stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Catcher_stmtContext)
else:
return self.getTypedRuleContext(ASLParser.Catcher_stmtContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_catcher_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCatcher_decl" ):
listener.enterCatcher_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCatcher_decl" ):
listener.exitCatcher_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCatcher_decl" ):
return visitor.visitCatcher_decl(self)
else:
return visitor.visitChildren(self)
def catcher_decl(self):
localctx = ASLParser.Catcher_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 164, self.RULE_catcher_decl)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 770
self.match(ASLParser.LBRACE)
self.state = 771
self.catcher_stmt()
self.state = 776
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 772
self.match(ASLParser.COMMA)
self.state = 773
self.catcher_stmt()
self.state = 778
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 779
self.match(ASLParser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Catcher_stmtContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def error_equals_decl(self):
return self.getTypedRuleContext(ASLParser.Error_equals_declContext,0)
def result_path_decl(self):
return self.getTypedRuleContext(ASLParser.Result_path_declContext,0)
def next_decl(self):
return self.getTypedRuleContext(ASLParser.Next_declContext,0)
def comment_decl(self):
return self.getTypedRuleContext(ASLParser.Comment_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_catcher_stmt
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterCatcher_stmt" ):
listener.enterCatcher_stmt(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitCatcher_stmt" ):
listener.exitCatcher_stmt(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitCatcher_stmt" ):
return visitor.visitCatcher_stmt(self)
else:
return visitor.visitChildren(self)
def catcher_stmt(self):
localctx = ASLParser.Catcher_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 166, self.RULE_catcher_stmt)
try:
self.state = 785
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [111]:
self.enterOuterAlt(localctx, 1)
self.state = 781
self.error_equals_decl()
pass
elif token in [93]:
self.enterOuterAlt(localctx, 2)
self.state = 782
self.result_path_decl()
pass
elif token in [104]:
self.enterOuterAlt(localctx, 3)
self.state = 783
self.next_decl()
pass
elif token in [10]:
self.enterOuterAlt(localctx, 4)
self.state = 784
self.comment_decl()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Comparison_opContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def BOOLEANEQUALS(self):
return self.getToken(ASLParser.BOOLEANEQUALS, 0)
def BOOLEANQUALSPATH(self):
return self.getToken(ASLParser.BOOLEANQUALSPATH, 0)
def ISBOOLEAN(self):
return self.getToken(ASLParser.ISBOOLEAN, 0)
def ISNULL(self):
return self.getToken(ASLParser.ISNULL, 0)
def ISNUMERIC(self):
return self.getToken(ASLParser.ISNUMERIC, 0)
def ISPRESENT(self):
return self.getToken(ASLParser.ISPRESENT, 0)
def ISSTRING(self):
return self.getToken(ASLParser.ISSTRING, 0)
def ISTIMESTAMP(self):
return self.getToken(ASLParser.ISTIMESTAMP, 0)
def NUMERICEQUALS(self):
return self.getToken(ASLParser.NUMERICEQUALS, 0)
def NUMERICEQUALSPATH(self):
return self.getToken(ASLParser.NUMERICEQUALSPATH, 0)
def NUMERICGREATERTHAN(self):
return self.getToken(ASLParser.NUMERICGREATERTHAN, 0)
def NUMERICGREATERTHANPATH(self):
return self.getToken(ASLParser.NUMERICGREATERTHANPATH, 0)
def NUMERICGREATERTHANEQUALS(self):
return self.getToken(ASLParser.NUMERICGREATERTHANEQUALS, 0)
def NUMERICGREATERTHANEQUALSPATH(self):
return self.getToken(ASLParser.NUMERICGREATERTHANEQUALSPATH, 0)
def NUMERICLESSTHAN(self):
return self.getToken(ASLParser.NUMERICLESSTHAN, 0)
def NUMERICLESSTHANPATH(self):
return self.getToken(ASLParser.NUMERICLESSTHANPATH, 0)
def NUMERICLESSTHANEQUALS(self):
return self.getToken(ASLParser.NUMERICLESSTHANEQUALS, 0)
def NUMERICLESSTHANEQUALSPATH(self):
return self.getToken(ASLParser.NUMERICLESSTHANEQUALSPATH, 0)
def STRINGEQUALS(self):
return self.getToken(ASLParser.STRINGEQUALS, 0)
def STRINGEQUALSPATH(self):
return self.getToken(ASLParser.STRINGEQUALSPATH, 0)
def STRINGGREATERTHAN(self):
return self.getToken(ASLParser.STRINGGREATERTHAN, 0)
def STRINGGREATERTHANPATH(self):
return self.getToken(ASLParser.STRINGGREATERTHANPATH, 0)
def STRINGGREATERTHANEQUALS(self):
return self.getToken(ASLParser.STRINGGREATERTHANEQUALS, 0)
def STRINGGREATERTHANEQUALSPATH(self):
return self.getToken(ASLParser.STRINGGREATERTHANEQUALSPATH, 0)
def STRINGLESSTHAN(self):
return self.getToken(ASLParser.STRINGLESSTHAN, 0)
def STRINGLESSTHANPATH(self):
return self.getToken(ASLParser.STRINGLESSTHANPATH, 0)
def STRINGLESSTHANEQUALS(self):
return self.getToken(ASLParser.STRINGLESSTHANEQUALS, 0)
def STRINGLESSTHANEQUALSPATH(self):
return self.getToken(ASLParser.STRINGLESSTHANEQUALSPATH, 0)
def STRINGMATCHES(self):
return self.getToken(ASLParser.STRINGMATCHES, 0)
def TIMESTAMPEQUALS(self):
return self.getToken(ASLParser.TIMESTAMPEQUALS, 0)
def TIMESTAMPEQUALSPATH(self):
return self.getToken(ASLParser.TIMESTAMPEQUALSPATH, 0)
def TIMESTAMPGREATERTHAN(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHAN, 0)
def TIMESTAMPGREATERTHANPATH(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHANPATH, 0)
def TIMESTAMPGREATERTHANEQUALS(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHANEQUALS, 0)
def TIMESTAMPGREATERTHANEQUALSPATH(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHANEQUALSPATH, 0)
def TIMESTAMPLESSTHAN(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHAN, 0)
def TIMESTAMPLESSTHANPATH(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHANPATH, 0)
def TIMESTAMPLESSTHANEQUALS(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHANEQUALS, 0)
def TIMESTAMPLESSTHANEQUALSPATH(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHANEQUALSPATH, 0)
def getRuleIndex(self):
return ASLParser.RULE_comparison_op
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComparison_op" ):
listener.enterComparison_op(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComparison_op" ):
listener.exitComparison_op(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComparison_op" ):
return visitor.visitComparison_op(self)
else:
return visitor.visitChildren(self)
def comparison_op(self):
localctx = ASLParser.Comparison_opContext(self, self._ctx, self.state)
self.enterRule(localctx, 168, self.RULE_comparison_op)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 787
_la = self._input.LA(1)
if not(((((_la - 29)) & ~0x3f) == 0 and ((1 << (_la - 29)) & 2199022731007) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Choice_operatorContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def NOT(self):
return self.getToken(ASLParser.NOT, 0)
def AND(self):
return self.getToken(ASLParser.AND, 0)
def OR(self):
return self.getToken(ASLParser.OR, 0)
def getRuleIndex(self):
return ASLParser.RULE_choice_operator
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterChoice_operator" ):
listener.enterChoice_operator(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitChoice_operator" ):
listener.exitChoice_operator(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitChoice_operator" ):
return visitor.visitChoice_operator(self)
else:
return visitor.visitChildren(self)
def choice_operator(self):
localctx = ASLParser.Choice_operatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 170, self.RULE_choice_operator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 789
_la = self._input.LA(1)
if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 281612684099584) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class States_error_nameContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def ERRORNAMEStatesALL(self):
return self.getToken(ASLParser.ERRORNAMEStatesALL, 0)
def ERRORNAMEStatesDataLimitExceeded(self):
return self.getToken(ASLParser.ERRORNAMEStatesDataLimitExceeded, 0)
def ERRORNAMEStatesHeartbeatTimeout(self):
return self.getToken(ASLParser.ERRORNAMEStatesHeartbeatTimeout, 0)
def ERRORNAMEStatesTimeout(self):
return self.getToken(ASLParser.ERRORNAMEStatesTimeout, 0)
def ERRORNAMEStatesTaskFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesTaskFailed, 0)
def ERRORNAMEStatesPermissions(self):
return self.getToken(ASLParser.ERRORNAMEStatesPermissions, 0)
def ERRORNAMEStatesResultPathMatchFailure(self):
return self.getToken(ASLParser.ERRORNAMEStatesResultPathMatchFailure, 0)
def ERRORNAMEStatesParameterPathFailure(self):
return self.getToken(ASLParser.ERRORNAMEStatesParameterPathFailure, 0)
def ERRORNAMEStatesBranchFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesBranchFailed, 0)
def ERRORNAMEStatesNoChoiceMatched(self):
return self.getToken(ASLParser.ERRORNAMEStatesNoChoiceMatched, 0)
def ERRORNAMEStatesIntrinsicFailure(self):
return self.getToken(ASLParser.ERRORNAMEStatesIntrinsicFailure, 0)
def ERRORNAMEStatesExceedToleratedFailureThreshold(self):
return self.getToken(ASLParser.ERRORNAMEStatesExceedToleratedFailureThreshold, 0)
def ERRORNAMEStatesItemReaderFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesItemReaderFailed, 0)
def ERRORNAMEStatesResultWriterFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesResultWriterFailed, 0)
def ERRORNAMEStatesRuntime(self):
return self.getToken(ASLParser.ERRORNAMEStatesRuntime, 0)
def getRuleIndex(self):
return ASLParser.RULE_states_error_name
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStates_error_name" ):
listener.enterStates_error_name(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStates_error_name" ):
listener.exitStates_error_name(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStates_error_name" ):
return visitor.visitStates_error_name(self)
else:
return visitor.visitChildren(self)
def states_error_name(self):
localctx = ASLParser.States_error_nameContext(self, self._ctx, self.state)
self.enterRule(localctx, 172, self.RULE_states_error_name)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 791
_la = self._input.LA(1)
if not(((((_la - 120)) & ~0x3f) == 0 and ((1 << (_la - 120)) & 32767) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Error_nameContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def states_error_name(self):
return self.getTypedRuleContext(ASLParser.States_error_nameContext,0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_error_name
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterError_name" ):
listener.enterError_name(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitError_name" ):
listener.exitError_name(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitError_name" ):
return visitor.visitError_name(self)
else:
return visitor.visitChildren(self)
def error_name(self):
localctx = ASLParser.Error_nameContext(self, self._ctx, self.state)
self.enterRule(localctx, 174, self.RULE_error_name)
try:
self.state = 795
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 793
self.states_error_name()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 794
self.keyword_or_string()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Json_obj_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACE(self):
return self.getToken(ASLParser.LBRACE, 0)
def json_binding(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Json_bindingContext)
else:
return self.getTypedRuleContext(ASLParser.Json_bindingContext,i)
def RBRACE(self):
return self.getToken(ASLParser.RBRACE, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_json_obj_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterJson_obj_decl" ):
listener.enterJson_obj_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitJson_obj_decl" ):
listener.exitJson_obj_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitJson_obj_decl" ):
return visitor.visitJson_obj_decl(self)
else:
return visitor.visitChildren(self)
def json_obj_decl(self):
localctx = ASLParser.Json_obj_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 176, self.RULE_json_obj_decl)
self._la = 0 # Token type
try:
self.state = 810
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 797
self.match(ASLParser.LBRACE)
self.state = 798
self.json_binding()
self.state = 803
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 799
self.match(ASLParser.COMMA)
self.state = 800
self.json_binding()
self.state = 805
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 806
self.match(ASLParser.RBRACE)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 808
self.match(ASLParser.LBRACE)
self.state = 809
self.match(ASLParser.RBRACE)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Json_bindingContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def COLON(self):
return self.getToken(ASLParser.COLON, 0)
def json_value_decl(self):
return self.getTypedRuleContext(ASLParser.Json_value_declContext,0)
def getRuleIndex(self):
return ASLParser.RULE_json_binding
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterJson_binding" ):
listener.enterJson_binding(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitJson_binding" ):
listener.exitJson_binding(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitJson_binding" ):
return visitor.visitJson_binding(self)
else:
return visitor.visitChildren(self)
def json_binding(self):
localctx = ASLParser.Json_bindingContext(self, self._ctx, self.state)
self.enterRule(localctx, 178, self.RULE_json_binding)
try:
self.enterOuterAlt(localctx, 1)
self.state = 812
self.keyword_or_string()
self.state = 813
self.match(ASLParser.COLON)
self.state = 814
self.json_value_decl()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Json_arr_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def LBRACK(self):
return self.getToken(ASLParser.LBRACK, 0)
def json_value_decl(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(ASLParser.Json_value_declContext)
else:
return self.getTypedRuleContext(ASLParser.Json_value_declContext,i)
def RBRACK(self):
return self.getToken(ASLParser.RBRACK, 0)
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(ASLParser.COMMA)
else:
return self.getToken(ASLParser.COMMA, i)
def getRuleIndex(self):
return ASLParser.RULE_json_arr_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterJson_arr_decl" ):
listener.enterJson_arr_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitJson_arr_decl" ):
listener.exitJson_arr_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitJson_arr_decl" ):
return visitor.visitJson_arr_decl(self)
else:
return visitor.visitChildren(self)
def json_arr_decl(self):
localctx = ASLParser.Json_arr_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 180, self.RULE_json_arr_decl)
self._la = 0 # Token type
try:
self.state = 829
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 816
self.match(ASLParser.LBRACK)
self.state = 817
self.json_value_decl()
self.state = 822
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==1:
self.state = 818
self.match(ASLParser.COMMA)
self.state = 819
self.json_value_decl()
self.state = 824
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 825
self.match(ASLParser.RBRACK)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 827
self.match(ASLParser.LBRACK)
self.state = 828
self.match(ASLParser.RBRACK)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Json_value_declContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def NUMBER(self):
return self.getToken(ASLParser.NUMBER, 0)
def INT(self):
return self.getToken(ASLParser.INT, 0)
def TRUE(self):
return self.getToken(ASLParser.TRUE, 0)
def FALSE(self):
return self.getToken(ASLParser.FALSE, 0)
def NULL(self):
return self.getToken(ASLParser.NULL, 0)
def json_binding(self):
return self.getTypedRuleContext(ASLParser.Json_bindingContext,0)
def json_arr_decl(self):
return self.getTypedRuleContext(ASLParser.Json_arr_declContext,0)
def json_obj_decl(self):
return self.getTypedRuleContext(ASLParser.Json_obj_declContext,0)
def keyword_or_string(self):
return self.getTypedRuleContext(ASLParser.Keyword_or_stringContext,0)
def getRuleIndex(self):
return ASLParser.RULE_json_value_decl
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterJson_value_decl" ):
listener.enterJson_value_decl(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitJson_value_decl" ):
listener.exitJson_value_decl(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitJson_value_decl" ):
return visitor.visitJson_value_decl(self)
else:
return visitor.visitChildren(self)
def json_value_decl(self):
localctx = ASLParser.Json_value_declContext(self, self._ctx, self.state)
self.enterRule(localctx, 182, self.RULE_json_value_decl)
try:
self.state = 840
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 831
self.match(ASLParser.NUMBER)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 832
self.match(ASLParser.INT)
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 833
self.match(ASLParser.TRUE)
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 834
self.match(ASLParser.FALSE)
pass
elif la_ == 5:
self.enterOuterAlt(localctx, 5)
self.state = 835
self.match(ASLParser.NULL)
pass
elif la_ == 6:
self.enterOuterAlt(localctx, 6)
self.state = 836
self.json_binding()
pass
elif la_ == 7:
self.enterOuterAlt(localctx, 7)
self.state = 837
self.json_arr_decl()
pass
elif la_ == 8:
self.enterOuterAlt(localctx, 8)
self.state = 838
self.json_obj_decl()
pass
elif la_ == 9:
self.enterOuterAlt(localctx, 9)
self.state = 839
self.keyword_or_string()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class Keyword_or_stringContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def STRINGDOLLAR(self):
return self.getToken(ASLParser.STRINGDOLLAR, 0)
def STRINGPATHCONTEXTOBJ(self):
return self.getToken(ASLParser.STRINGPATHCONTEXTOBJ, 0)
def STRINGPATH(self):
return self.getToken(ASLParser.STRINGPATH, 0)
def STRING(self):
return self.getToken(ASLParser.STRING, 0)
def COMMENT(self):
return self.getToken(ASLParser.COMMENT, 0)
def STATES(self):
return self.getToken(ASLParser.STATES, 0)
def STARTAT(self):
return self.getToken(ASLParser.STARTAT, 0)
def NEXTSTATE(self):
return self.getToken(ASLParser.NEXTSTATE, 0)
def TYPE(self):
return self.getToken(ASLParser.TYPE, 0)
def TASK(self):
return self.getToken(ASLParser.TASK, 0)
def CHOICE(self):
return self.getToken(ASLParser.CHOICE, 0)
def FAIL(self):
return self.getToken(ASLParser.FAIL, 0)
def SUCCEED(self):
return self.getToken(ASLParser.SUCCEED, 0)
def PASS(self):
return self.getToken(ASLParser.PASS, 0)
def WAIT(self):
return self.getToken(ASLParser.WAIT, 0)
def PARALLEL(self):
return self.getToken(ASLParser.PARALLEL, 0)
def MAP(self):
return self.getToken(ASLParser.MAP, 0)
def CHOICES(self):
return self.getToken(ASLParser.CHOICES, 0)
def VARIABLE(self):
return self.getToken(ASLParser.VARIABLE, 0)
def DEFAULT(self):
return self.getToken(ASLParser.DEFAULT, 0)
def BRANCHES(self):
return self.getToken(ASLParser.BRANCHES, 0)
def AND(self):
return self.getToken(ASLParser.AND, 0)
def BOOLEANEQUALS(self):
return self.getToken(ASLParser.BOOLEANEQUALS, 0)
def BOOLEANQUALSPATH(self):
return self.getToken(ASLParser.BOOLEANQUALSPATH, 0)
def ISBOOLEAN(self):
return self.getToken(ASLParser.ISBOOLEAN, 0)
def ISNULL(self):
return self.getToken(ASLParser.ISNULL, 0)
def ISNUMERIC(self):
return self.getToken(ASLParser.ISNUMERIC, 0)
def ISPRESENT(self):
return self.getToken(ASLParser.ISPRESENT, 0)
def ISSTRING(self):
return self.getToken(ASLParser.ISSTRING, 0)
def ISTIMESTAMP(self):
return self.getToken(ASLParser.ISTIMESTAMP, 0)
def NOT(self):
return self.getToken(ASLParser.NOT, 0)
def NUMERICEQUALS(self):
return self.getToken(ASLParser.NUMERICEQUALS, 0)
def NUMERICEQUALSPATH(self):
return self.getToken(ASLParser.NUMERICEQUALSPATH, 0)
def NUMERICGREATERTHAN(self):
return self.getToken(ASLParser.NUMERICGREATERTHAN, 0)
def NUMERICGREATERTHANPATH(self):
return self.getToken(ASLParser.NUMERICGREATERTHANPATH, 0)
def NUMERICGREATERTHANEQUALS(self):
return self.getToken(ASLParser.NUMERICGREATERTHANEQUALS, 0)
def NUMERICGREATERTHANEQUALSPATH(self):
return self.getToken(ASLParser.NUMERICGREATERTHANEQUALSPATH, 0)
def NUMERICLESSTHAN(self):
return self.getToken(ASLParser.NUMERICLESSTHAN, 0)
def NUMERICLESSTHANPATH(self):
return self.getToken(ASLParser.NUMERICLESSTHANPATH, 0)
def NUMERICLESSTHANEQUALS(self):
return self.getToken(ASLParser.NUMERICLESSTHANEQUALS, 0)
def NUMERICLESSTHANEQUALSPATH(self):
return self.getToken(ASLParser.NUMERICLESSTHANEQUALSPATH, 0)
def OR(self):
return self.getToken(ASLParser.OR, 0)
def STRINGEQUALS(self):
return self.getToken(ASLParser.STRINGEQUALS, 0)
def STRINGEQUALSPATH(self):
return self.getToken(ASLParser.STRINGEQUALSPATH, 0)
def STRINGGREATERTHAN(self):
return self.getToken(ASLParser.STRINGGREATERTHAN, 0)
def STRINGGREATERTHANPATH(self):
return self.getToken(ASLParser.STRINGGREATERTHANPATH, 0)
def STRINGGREATERTHANEQUALS(self):
return self.getToken(ASLParser.STRINGGREATERTHANEQUALS, 0)
def STRINGGREATERTHANEQUALSPATH(self):
return self.getToken(ASLParser.STRINGGREATERTHANEQUALSPATH, 0)
def STRINGLESSTHAN(self):
return self.getToken(ASLParser.STRINGLESSTHAN, 0)
def STRINGLESSTHANPATH(self):
return self.getToken(ASLParser.STRINGLESSTHANPATH, 0)
def STRINGLESSTHANEQUALS(self):
return self.getToken(ASLParser.STRINGLESSTHANEQUALS, 0)
def STRINGLESSTHANEQUALSPATH(self):
return self.getToken(ASLParser.STRINGLESSTHANEQUALSPATH, 0)
def STRINGMATCHES(self):
return self.getToken(ASLParser.STRINGMATCHES, 0)
def TIMESTAMPEQUALS(self):
return self.getToken(ASLParser.TIMESTAMPEQUALS, 0)
def TIMESTAMPEQUALSPATH(self):
return self.getToken(ASLParser.TIMESTAMPEQUALSPATH, 0)
def TIMESTAMPGREATERTHAN(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHAN, 0)
def TIMESTAMPGREATERTHANPATH(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHANPATH, 0)
def TIMESTAMPGREATERTHANEQUALS(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHANEQUALS, 0)
def TIMESTAMPGREATERTHANEQUALSPATH(self):
return self.getToken(ASLParser.TIMESTAMPGREATERTHANEQUALSPATH, 0)
def TIMESTAMPLESSTHAN(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHAN, 0)
def TIMESTAMPLESSTHANPATH(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHANPATH, 0)
def TIMESTAMPLESSTHANEQUALS(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHANEQUALS, 0)
def TIMESTAMPLESSTHANEQUALSPATH(self):
return self.getToken(ASLParser.TIMESTAMPLESSTHANEQUALSPATH, 0)
def SECONDSPATH(self):
return self.getToken(ASLParser.SECONDSPATH, 0)
def SECONDS(self):
return self.getToken(ASLParser.SECONDS, 0)
def TIMESTAMPPATH(self):
return self.getToken(ASLParser.TIMESTAMPPATH, 0)
def TIMESTAMP(self):
return self.getToken(ASLParser.TIMESTAMP, 0)
def TIMEOUTSECONDS(self):
return self.getToken(ASLParser.TIMEOUTSECONDS, 0)
def TIMEOUTSECONDSPATH(self):
return self.getToken(ASLParser.TIMEOUTSECONDSPATH, 0)
def HEARTBEATSECONDS(self):
return self.getToken(ASLParser.HEARTBEATSECONDS, 0)
def HEARTBEATSECONDSPATH(self):
return self.getToken(ASLParser.HEARTBEATSECONDSPATH, 0)
def PROCESSORCONFIG(self):
return self.getToken(ASLParser.PROCESSORCONFIG, 0)
def MODE(self):
return self.getToken(ASLParser.MODE, 0)
def INLINE(self):
return self.getToken(ASLParser.INLINE, 0)
def DISTRIBUTED(self):
return self.getToken(ASLParser.DISTRIBUTED, 0)
def EXECUTIONTYPE(self):
return self.getToken(ASLParser.EXECUTIONTYPE, 0)
def STANDARD(self):
return self.getToken(ASLParser.STANDARD, 0)
def ITEMPROCESSOR(self):
return self.getToken(ASLParser.ITEMPROCESSOR, 0)
def ITERATOR(self):
return self.getToken(ASLParser.ITERATOR, 0)
def ITEMSELECTOR(self):
return self.getToken(ASLParser.ITEMSELECTOR, 0)
def MAXCONCURRENCY(self):
return self.getToken(ASLParser.MAXCONCURRENCY, 0)
def MAXCONCURRENCYPATH(self):
return self.getToken(ASLParser.MAXCONCURRENCYPATH, 0)
def RESOURCE(self):
return self.getToken(ASLParser.RESOURCE, 0)
def INPUTPATH(self):
return self.getToken(ASLParser.INPUTPATH, 0)
def OUTPUTPATH(self):
return self.getToken(ASLParser.OUTPUTPATH, 0)
def ITEMSPATH(self):
return self.getToken(ASLParser.ITEMSPATH, 0)
def RESULTPATH(self):
return self.getToken(ASLParser.RESULTPATH, 0)
def RESULT(self):
return self.getToken(ASLParser.RESULT, 0)
def PARAMETERS(self):
return self.getToken(ASLParser.PARAMETERS, 0)
def RESULTSELECTOR(self):
return self.getToken(ASLParser.RESULTSELECTOR, 0)
def ITEMREADER(self):
return self.getToken(ASLParser.ITEMREADER, 0)
def READERCONFIG(self):
return self.getToken(ASLParser.READERCONFIG, 0)
def INPUTTYPE(self):
return self.getToken(ASLParser.INPUTTYPE, 0)
def CSVHEADERLOCATION(self):
return self.getToken(ASLParser.CSVHEADERLOCATION, 0)
def CSVHEADERS(self):
return self.getToken(ASLParser.CSVHEADERS, 0)
def MAXITEMS(self):
return self.getToken(ASLParser.MAXITEMS, 0)
def MAXITEMSPATH(self):
return self.getToken(ASLParser.MAXITEMSPATH, 0)
def NEXT(self):
return self.getToken(ASLParser.NEXT, 0)
def END(self):
return self.getToken(ASLParser.END, 0)
def CAUSE(self):
return self.getToken(ASLParser.CAUSE, 0)
def ERROR(self):
return self.getToken(ASLParser.ERROR, 0)
def RETRY(self):
return self.getToken(ASLParser.RETRY, 0)
def ERROREQUALS(self):
return self.getToken(ASLParser.ERROREQUALS, 0)
def INTERVALSECONDS(self):
return self.getToken(ASLParser.INTERVALSECONDS, 0)
def MAXATTEMPTS(self):
return self.getToken(ASLParser.MAXATTEMPTS, 0)
def BACKOFFRATE(self):
return self.getToken(ASLParser.BACKOFFRATE, 0)
def MAXDELAYSECONDS(self):
return self.getToken(ASLParser.MAXDELAYSECONDS, 0)
def JITTERSTRATEGY(self):
return self.getToken(ASLParser.JITTERSTRATEGY, 0)
def FULL(self):
return self.getToken(ASLParser.FULL, 0)
def NONE(self):
return self.getToken(ASLParser.NONE, 0)
def CATCH(self):
return self.getToken(ASLParser.CATCH, 0)
def ERRORNAMEStatesALL(self):
return self.getToken(ASLParser.ERRORNAMEStatesALL, 0)
def ERRORNAMEStatesHeartbeatTimeout(self):
return self.getToken(ASLParser.ERRORNAMEStatesHeartbeatTimeout, 0)
def ERRORNAMEStatesTimeout(self):
return self.getToken(ASLParser.ERRORNAMEStatesTimeout, 0)
def ERRORNAMEStatesTaskFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesTaskFailed, 0)
def ERRORNAMEStatesPermissions(self):
return self.getToken(ASLParser.ERRORNAMEStatesPermissions, 0)
def ERRORNAMEStatesResultPathMatchFailure(self):
return self.getToken(ASLParser.ERRORNAMEStatesResultPathMatchFailure, 0)
def ERRORNAMEStatesParameterPathFailure(self):
return self.getToken(ASLParser.ERRORNAMEStatesParameterPathFailure, 0)
def ERRORNAMEStatesBranchFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesBranchFailed, 0)
def ERRORNAMEStatesNoChoiceMatched(self):
return self.getToken(ASLParser.ERRORNAMEStatesNoChoiceMatched, 0)
def ERRORNAMEStatesIntrinsicFailure(self):
return self.getToken(ASLParser.ERRORNAMEStatesIntrinsicFailure, 0)
def ERRORNAMEStatesExceedToleratedFailureThreshold(self):
return self.getToken(ASLParser.ERRORNAMEStatesExceedToleratedFailureThreshold, 0)
def ERRORNAMEStatesItemReaderFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesItemReaderFailed, 0)
def ERRORNAMEStatesResultWriterFailed(self):
return self.getToken(ASLParser.ERRORNAMEStatesResultWriterFailed, 0)
def ERRORNAMEStatesRuntime(self):
return self.getToken(ASLParser.ERRORNAMEStatesRuntime, 0)
def getRuleIndex(self):
return ASLParser.RULE_keyword_or_string
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterKeyword_or_string" ):
listener.enterKeyword_or_string(self)
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitKeyword_or_string" ):
listener.exitKeyword_or_string(self)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitKeyword_or_string" ):
return visitor.visitKeyword_or_string(self)
else:
return visitor.visitChildren(self)
def keyword_or_string(self):
localctx = ASLParser.Keyword_or_stringContext(self, self._ctx, self.state)
self.enterRule(localctx, 184, self.RULE_keyword_or_string)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 842
_la = self._input.LA(1)
if not((((_la) & ~0x3f) == 0 and ((1 << _la) & -17408) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -144159168540966913) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 2047) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx