Coverage for src/pyensae/languages/SimpleWorkflowParser.py: 0%
1443 statements
« prev ^ index » next coverage.py v7.2.7, created at 2023-07-03 02:16 +0200
1# Generated from \SimpleWorkflow.g4 by ANTLR 4.10.1
2# encoding: utf-8
3from antlr4 import *
4from io import StringIO
5import sys
6if sys.version_info[1] > 5:
7 from typing import TextIO
8else:
9 from typing.io import TextIO
12def serializedATN():
13 return [
14 4, 1, 41, 274, 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,
15 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,
16 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,
17 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,
18 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 1, 0, 5, 0, 66, 8, 0,
19 10, 0, 12, 0, 69, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 77, 8, 1, 1, 2, 1, 2, 1, 2,
20 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 4, 4, 95, 8, 4, 11,
21 4, 12, 4, 96, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 107, 8, 5, 11, 5, 12, 5,
22 108, 1, 5, 1, 5, 1, 5, 1, 5, 4, 5, 115, 8, 5, 11, 5, 12, 5, 116, 1, 5, 1, 5, 3, 5, 121, 8,
23 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 130, 8, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1,
24 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 143, 8, 8, 1, 9, 1, 9, 1, 9, 3, 9, 148, 8, 9, 1, 9, 1,
25 9, 5, 9, 152, 8, 9, 10, 9, 12, 9, 155, 9, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12,
26 1, 12, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 3, 14, 171, 8, 14, 1, 15, 1, 15, 1, 15,
27 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 185, 8, 15, 1, 16,
28 1, 16, 1, 16, 3, 16, 190, 8, 16, 1, 17, 1, 17, 1, 17, 3, 17, 195, 8, 17, 1, 18, 1, 18, 1,
29 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1,
30 22, 3, 22, 213, 8, 22, 1, 22, 1, 22, 5, 22, 217, 8, 22, 10, 22, 12, 22, 220, 9, 22, 1,
31 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1,
32 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 3, 28, 241, 8, 28, 1, 29, 1, 29, 1, 30, 3, 30, 246,
33 8, 30, 1, 30, 1, 30, 1, 31, 3, 31, 251, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31,
34 258, 8, 31, 1, 31, 3, 31, 261, 8, 31, 1, 31, 3, 31, 264, 8, 31, 1, 31, 1, 31, 1, 31, 3,
35 31, 269, 8, 31, 1, 31, 3, 31, 272, 8, 31, 1, 31, 0, 0, 32, 0, 2, 4, 6, 8, 10, 12, 14, 16,
36 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
37 62, 0, 4, 1, 0, 13, 25, 2, 0, 13, 14, 26, 26, 1, 0, 28, 29, 2, 0, 35, 35, 37, 37, 273, 0,
38 67, 1, 0, 0, 0, 2, 76, 1, 0, 0, 0, 4, 78, 1, 0, 0, 0, 6, 81, 1, 0, 0, 0, 8, 86, 1, 0, 0, 0, 10,
39 100, 1, 0, 0, 0, 12, 122, 1, 0, 0, 0, 14, 129, 1, 0, 0, 0, 16, 142, 1, 0, 0, 0, 18, 144,
40 1, 0, 0, 0, 20, 158, 1, 0, 0, 0, 22, 160, 1, 0, 0, 0, 24, 162, 1, 0, 0, 0, 26, 164, 1, 0,
41 0, 0, 28, 170, 1, 0, 0, 0, 30, 184, 1, 0, 0, 0, 32, 186, 1, 0, 0, 0, 34, 191, 1, 0, 0, 0,
42 36, 196, 1, 0, 0, 0, 38, 200, 1, 0, 0, 0, 40, 204, 1, 0, 0, 0, 42, 209, 1, 0, 0, 0, 44, 212,
43 1, 0, 0, 0, 46, 221, 1, 0, 0, 0, 48, 225, 1, 0, 0, 0, 50, 227, 1, 0, 0, 0, 52, 229, 1, 0,
44 0, 0, 54, 233, 1, 0, 0, 0, 56, 240, 1, 0, 0, 0, 58, 242, 1, 0, 0, 0, 60, 245, 1, 0, 0, 0,
45 62, 271, 1, 0, 0, 0, 64, 66, 3, 2, 1, 0, 65, 64, 1, 0, 0, 0, 66, 69, 1, 0, 0, 0, 67, 65, 1,
46 0, 0, 0, 67, 68, 1, 0, 0, 0, 68, 70, 1, 0, 0, 0, 69, 67, 1, 0, 0, 0, 70, 71, 5, 0, 0, 1, 71,
47 1, 1, 0, 0, 0, 72, 77, 3, 10, 5, 0, 73, 77, 3, 8, 4, 0, 74, 77, 3, 4, 2, 0, 75, 77, 3, 26,
48 13, 0, 76, 72, 1, 0, 0, 0, 76, 73, 1, 0, 0, 0, 76, 74, 1, 0, 0, 0, 76, 75, 1, 0, 0, 0, 77,
49 3, 1, 0, 0, 0, 78, 79, 3, 6, 3, 0, 79, 80, 5, 1, 0, 0, 80, 5, 1, 0, 0, 0, 81, 82, 5, 2, 0, 0,
50 82, 83, 3, 20, 10, 0, 83, 84, 5, 3, 0, 0, 84, 85, 3, 14, 7, 0, 85, 7, 1, 0, 0, 0, 86, 87,
51 5, 4, 0, 0, 87, 88, 5, 5, 0, 0, 88, 89, 3, 20, 10, 0, 89, 90, 5, 6, 0, 0, 90, 91, 3, 18, 9,
52 0, 91, 92, 5, 7, 0, 0, 92, 94, 5, 8, 0, 0, 93, 95, 3, 2, 1, 0, 94, 93, 1, 0, 0, 0, 95, 96,
53 1, 0, 0, 0, 96, 94, 1, 0, 0, 0, 96, 97, 1, 0, 0, 0, 97, 98, 1, 0, 0, 0, 98, 99, 5, 9, 0, 0,
54 99, 9, 1, 0, 0, 0, 100, 101, 5, 10, 0, 0, 101, 102, 5, 5, 0, 0, 102, 103, 3, 14, 7, 0, 103,
55 104, 5, 7, 0, 0, 104, 106, 5, 8, 0, 0, 105, 107, 3, 2, 1, 0, 106, 105, 1, 0, 0, 0, 107,
56 108, 1, 0, 0, 0, 108, 106, 1, 0, 0, 0, 108, 109, 1, 0, 0, 0, 109, 110, 1, 0, 0, 0, 110,
57 120, 5, 9, 0, 0, 111, 112, 5, 11, 0, 0, 112, 114, 5, 8, 0, 0, 113, 115, 3, 2, 1, 0, 114,
58 113, 1, 0, 0, 0, 115, 116, 1, 0, 0, 0, 116, 114, 1, 0, 0, 0, 116, 117, 1, 0, 0, 0, 117,
59 118, 1, 0, 0, 0, 118, 119, 5, 9, 0, 0, 119, 121, 1, 0, 0, 0, 120, 111, 1, 0, 0, 0, 120,
60 121, 1, 0, 0, 0, 121, 11, 1, 0, 0, 0, 122, 123, 5, 35, 0, 0, 123, 13, 1, 0, 0, 0, 124, 130,
61 3, 16, 8, 0, 125, 126, 3, 16, 8, 0, 126, 127, 3, 22, 11, 0, 127, 128, 3, 14, 7, 0, 128,
62 130, 1, 0, 0, 0, 129, 124, 1, 0, 0, 0, 129, 125, 1, 0, 0, 0, 130, 15, 1, 0, 0, 0, 131, 143,
63 3, 56, 28, 0, 132, 143, 3, 20, 10, 0, 133, 143, 3, 32, 16, 0, 134, 135, 5, 5, 0, 0, 135,
64 136, 3, 14, 7, 0, 136, 137, 5, 7, 0, 0, 137, 143, 1, 0, 0, 0, 138, 139, 3, 24, 12, 0, 139,
65 140, 3, 16, 8, 0, 140, 143, 1, 0, 0, 0, 141, 143, 3, 18, 9, 0, 142, 131, 1, 0, 0, 0, 142,
66 132, 1, 0, 0, 0, 142, 133, 1, 0, 0, 0, 142, 134, 1, 0, 0, 0, 142, 138, 1, 0, 0, 0, 142,
67 141, 1, 0, 0, 0, 143, 17, 1, 0, 0, 0, 144, 145, 3, 12, 6, 0, 145, 147, 5, 5, 0, 0, 146,
68 148, 3, 14, 7, 0, 147, 146, 1, 0, 0, 0, 147, 148, 1, 0, 0, 0, 148, 153, 1, 0, 0, 0, 149,
69 150, 5, 12, 0, 0, 150, 152, 3, 14, 7, 0, 151, 149, 1, 0, 0, 0, 152, 155, 1, 0, 0, 0, 153,
70 151, 1, 0, 0, 0, 153, 154, 1, 0, 0, 0, 154, 156, 1, 0, 0, 0, 155, 153, 1, 0, 0, 0, 156,
71 157, 5, 7, 0, 0, 157, 19, 1, 0, 0, 0, 158, 159, 5, 35, 0, 0, 159, 21, 1, 0, 0, 0, 160, 161,
72 7, 0, 0, 0, 161, 23, 1, 0, 0, 0, 162, 163, 7, 1, 0, 0, 163, 25, 1, 0, 0, 0, 164, 165, 3,
73 28, 14, 0, 165, 166, 5, 1, 0, 0, 166, 27, 1, 0, 0, 0, 167, 171, 3, 30, 15, 0, 168, 171,
74 3, 36, 18, 0, 169, 171, 3, 38, 19, 0, 170, 167, 1, 0, 0, 0, 170, 168, 1, 0, 0, 0, 170,
75 169, 1, 0, 0, 0, 171, 29, 1, 0, 0, 0, 172, 173, 5, 27, 0, 0, 173, 174, 3, 32, 16, 0, 174,
76 175, 7, 2, 0, 0, 175, 176, 3, 34, 17, 0, 176, 185, 1, 0, 0, 0, 177, 178, 5, 27, 0, 0, 178,
77 179, 5, 5, 0, 0, 179, 180, 3, 32, 16, 0, 180, 181, 5, 12, 0, 0, 181, 182, 3, 34, 17, 0,
78 182, 183, 5, 7, 0, 0, 183, 185, 1, 0, 0, 0, 184, 172, 1, 0, 0, 0, 184, 177, 1, 0, 0, 0,
79 185, 31, 1, 0, 0, 0, 186, 189, 3, 42, 21, 0, 187, 188, 5, 30, 0, 0, 188, 190, 3, 50, 25,
80 0, 189, 187, 1, 0, 0, 0, 189, 190, 1, 0, 0, 0, 190, 33, 1, 0, 0, 0, 191, 194, 3, 42, 21,
81 0, 192, 193, 5, 30, 0, 0, 193, 195, 3, 50, 25, 0, 194, 192, 1, 0, 0, 0, 194, 195, 1, 0,
82 0, 0, 195, 35, 1, 0, 0, 0, 196, 197, 3, 42, 21, 0, 197, 198, 5, 3, 0, 0, 198, 199, 3, 54,
83 27, 0, 199, 37, 1, 0, 0, 0, 200, 201, 3, 42, 21, 0, 201, 202, 5, 3, 0, 0, 202, 203, 3,
84 40, 20, 0, 203, 39, 1, 0, 0, 0, 204, 205, 3, 52, 26, 0, 205, 206, 5, 5, 0, 0, 206, 207,
85 3, 44, 22, 0, 207, 208, 5, 7, 0, 0, 208, 41, 1, 0, 0, 0, 209, 210, 5, 35, 0, 0, 210, 43,
86 1, 0, 0, 0, 211, 213, 3, 46, 23, 0, 212, 211, 1, 0, 0, 0, 212, 213, 1, 0, 0, 0, 213, 218,
87 1, 0, 0, 0, 214, 215, 5, 12, 0, 0, 215, 217, 3, 46, 23, 0, 216, 214, 1, 0, 0, 0, 217, 220,
88 1, 0, 0, 0, 218, 216, 1, 0, 0, 0, 218, 219, 1, 0, 0, 0, 219, 45, 1, 0, 0, 0, 220, 218, 1,
89 0, 0, 0, 221, 222, 3, 48, 24, 0, 222, 223, 5, 3, 0, 0, 223, 224, 3, 14, 7, 0, 224, 47,
90 1, 0, 0, 0, 225, 226, 5, 35, 0, 0, 226, 49, 1, 0, 0, 0, 227, 228, 5, 35, 0, 0, 228, 51,
91 1, 0, 0, 0, 229, 230, 5, 31, 0, 0, 230, 231, 5, 30, 0, 0, 231, 232, 7, 3, 0, 0, 232, 53,
92 1, 0, 0, 0, 233, 234, 5, 32, 0, 0, 234, 235, 5, 30, 0, 0, 235, 236, 7, 3, 0, 0, 236, 55,
93 1, 0, 0, 0, 237, 241, 3, 60, 30, 0, 238, 241, 3, 62, 31, 0, 239, 241, 3, 58, 29, 0, 240,
94 237, 1, 0, 0, 0, 240, 238, 1, 0, 0, 0, 240, 239, 1, 0, 0, 0, 241, 57, 1, 0, 0, 0, 242, 243,
95 5, 37, 0, 0, 243, 59, 1, 0, 0, 0, 244, 246, 5, 36, 0, 0, 245, 244, 1, 0, 0, 0, 245, 246,
96 1, 0, 0, 0, 246, 247, 1, 0, 0, 0, 247, 248, 5, 34, 0, 0, 248, 61, 1, 0, 0, 0, 249, 251,
97 5, 36, 0, 0, 250, 249, 1, 0, 0, 0, 250, 251, 1, 0, 0, 0, 251, 252, 1, 0, 0, 0, 252, 253,
98 5, 34, 0, 0, 253, 254, 5, 30, 0, 0, 254, 260, 5, 34, 0, 0, 255, 257, 5, 33, 0, 0, 256,
99 258, 5, 36, 0, 0, 257, 256, 1, 0, 0, 0, 257, 258, 1, 0, 0, 0, 258, 259, 1, 0, 0, 0, 259,
100 261, 5, 34, 0, 0, 260, 255, 1, 0, 0, 0, 260, 261, 1, 0, 0, 0, 261, 272, 1, 0, 0, 0, 262,
101 264, 5, 36, 0, 0, 263, 262, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0, 264, 265, 1, 0, 0, 0, 265,
102 266, 5, 34, 0, 0, 266, 268, 5, 33, 0, 0, 267, 269, 5, 36, 0, 0, 268, 267, 1, 0, 0, 0, 268,
103 269, 1, 0, 0, 0, 269, 270, 1, 0, 0, 0, 270, 272, 5, 34, 0, 0, 271, 250, 1, 0, 0, 0, 271,
104 263, 1, 0, 0, 0, 272, 63, 1, 0, 0, 0, 24, 67, 76, 96, 108, 116, 120, 129, 142, 147, 153,
105 170, 184, 189, 194, 212, 218, 240, 245, 250, 257, 260, 263, 268, 271
106 ]
109class SimpleWorkflowParser (Parser):
111 grammarFileName = "SimpleWorkflow.g4"
113 atn = ATNDeserializer().deserialize(serializedATN())
115 decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
117 sharedContextCache = PredictionContextCache()
119 literalNames = ["<INVALID>", "';'", "'set'", "'='", "'for'", "'('",
120 "'in'", "')'", "'{'", "'}'", "'if'", "'else'", "','",
121 "'+'", "'-'", "'*'", "'/'", "'%'", "'&&'", "'||'",
122 "'=='", "'!='", "'<='", "'>='", "'>'", "'<'", "'!'",
123 "'connect'", "'to'", "'->'", "'.'", "'flowmodule'",
124 "'flowdata'", "'e'"]
126 symbolicNames = ["<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
127 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
128 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
129 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
130 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
131 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
132 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
133 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
134 "<INVALID>", "<INVALID>", "Digits", "Identifier",
135 "Sign", "STRING", "STRING_DOUBLE_QUOTE", "STRING_QUOTE",
136 "LINE_COMMENT", "WS"]
138 RULE_parse = 0
139 RULE_final_stmt = 1
140 RULE_affectation_stmt_comma = 2
141 RULE_affectation_stmt = 3
142 RULE_for_stmt = 4
143 RULE_if_stmt = 5
144 RULE_evaluation_function = 6
145 RULE_expression = 7
146 RULE_expression_no_binary = 8
147 RULE_function_call = 9
148 RULE_variable_name = 10
149 RULE_binary_operator = 11
150 RULE_unary_operator = 12
151 RULE_stmt_comma = 13
152 RULE_stmt = 14
153 RULE_connect_stmt = 15
154 RULE_data_or_module_output = 16
155 RULE_module_input = 17
156 RULE_data_stmt = 18
157 RULE_module_stmt = 19
158 RULE_module_call = 20
159 RULE_element_name = 21
160 RULE_list_param_affectation = 22
161 RULE_param_affectation = 23
162 RULE_param_name = 24
163 RULE_inout_name = 25
164 RULE_module_name = 26
165 RULE_data_name = 27
166 RULE_constant = 28
167 RULE_string_literal = 29
168 RULE_integer_number = 30
169 RULE_real_number = 31
171 ruleNames = ["parse", "final_stmt", "affectation_stmt_comma", "affectation_stmt",
172 "for_stmt", "if_stmt", "evaluation_function", "expression",
173 "expression_no_binary", "function_call", "variable_name",
174 "binary_operator", "unary_operator", "stmt_comma", "stmt",
175 "connect_stmt", "data_or_module_output", "module_input",
176 "data_stmt", "module_stmt", "module_call", "element_name",
177 "list_param_affectation", "param_affectation", "param_name",
178 "inout_name", "module_name", "data_name", "constant",
179 "string_literal", "integer_number", "real_number"]
181 EOF = Token.EOF
182 T__0 = 1
183 T__1 = 2
184 T__2 = 3
185 T__3 = 4
186 T__4 = 5
187 T__5 = 6
188 T__6 = 7
189 T__7 = 8
190 T__8 = 9
191 T__9 = 10
192 T__10 = 11
193 T__11 = 12
194 T__12 = 13
195 T__13 = 14
196 T__14 = 15
197 T__15 = 16
198 T__16 = 17
199 T__17 = 18
200 T__18 = 19
201 T__19 = 20
202 T__20 = 21
203 T__21 = 22
204 T__22 = 23
205 T__23 = 24
206 T__24 = 25
207 T__25 = 26
208 T__26 = 27
209 T__27 = 28
210 T__28 = 29
211 T__29 = 30
212 T__30 = 31
213 T__31 = 32
214 T__32 = 33
215 Digits = 34
216 Identifier = 35
217 Sign = 36
218 STRING = 37
219 STRING_DOUBLE_QUOTE = 38
220 STRING_QUOTE = 39
221 LINE_COMMENT = 40
222 WS = 41
224 def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
225 super().__init__(input, output)
226 self.checkVersion("4.10.1")
227 self._interp = ParserATNSimulator(
228 self, self.atn, self.decisionsToDFA, self.sharedContextCache)
229 self._predicates = None
231 class ParseContext(ParserRuleContext):
232 __slots__ = 'parser'
234 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
235 super().__init__(parent, invokingState)
236 self.parser = parser
238 def EOF(self):
239 return self.getToken(SimpleWorkflowParser.EOF, 0)
241 def final_stmt(self, i: int = None):
242 if i is None:
243 return self.getTypedRuleContexts(SimpleWorkflowParser.Final_stmtContext)
244 else:
245 return self.getTypedRuleContext(SimpleWorkflowParser.Final_stmtContext, i)
247 def getRuleIndex(self):
248 return SimpleWorkflowParser.RULE_parse
250 def enterRule(self, listener: ParseTreeListener):
251 if hasattr(listener, "enterParse"):
252 listener.enterParse(self)
254 def exitRule(self, listener: ParseTreeListener):
255 if hasattr(listener, "exitParse"):
256 listener.exitParse(self)
258 def parse(self):
260 localctx = SimpleWorkflowParser.ParseContext(
261 self, self._ctx, self.state)
262 self.enterRule(localctx, 0, self.RULE_parse)
263 self._la = 0 # Token type
264 try:
265 self.enterOuterAlt(localctx, 1)
266 self.state = 67
267 self._errHandler.sync(self)
268 _la = self._input.LA(1)
269 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SimpleWorkflowParser.T__1) | (1 << SimpleWorkflowParser.T__3) | (1 << SimpleWorkflowParser.T__9) | (1 << SimpleWorkflowParser.T__26) | (1 << SimpleWorkflowParser.Identifier))) != 0):
270 self.state = 64
271 self.final_stmt()
272 self.state = 69
273 self._errHandler.sync(self)
274 _la = self._input.LA(1)
276 self.state = 70
277 self.match(SimpleWorkflowParser.EOF)
278 except RecognitionException as re:
279 localctx.exception = re
280 self._errHandler.reportError(self, re)
281 self._errHandler.recover(self, re)
282 finally:
283 self.exitRule()
284 return localctx
286 class Final_stmtContext(ParserRuleContext):
287 __slots__ = 'parser'
289 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
290 super().__init__(parent, invokingState)
291 self.parser = parser
293 def if_stmt(self):
294 return self.getTypedRuleContext(SimpleWorkflowParser.If_stmtContext, 0)
296 def for_stmt(self):
297 return self.getTypedRuleContext(SimpleWorkflowParser.For_stmtContext, 0)
299 def affectation_stmt_comma(self):
300 return self.getTypedRuleContext(SimpleWorkflowParser.Affectation_stmt_commaContext, 0)
302 def stmt_comma(self):
303 return self.getTypedRuleContext(SimpleWorkflowParser.Stmt_commaContext, 0)
305 def getRuleIndex(self):
306 return SimpleWorkflowParser.RULE_final_stmt
308 def enterRule(self, listener: ParseTreeListener):
309 if hasattr(listener, "enterFinal_stmt"):
310 listener.enterFinal_stmt(self)
312 def exitRule(self, listener: ParseTreeListener):
313 if hasattr(listener, "exitFinal_stmt"):
314 listener.exitFinal_stmt(self)
316 def final_stmt(self):
318 localctx = SimpleWorkflowParser.Final_stmtContext(
319 self, self._ctx, self.state)
320 self.enterRule(localctx, 2, self.RULE_final_stmt)
321 try:
322 self.state = 76
323 self._errHandler.sync(self)
324 token = self._input.LA(1)
325 if token in [SimpleWorkflowParser.T__9]:
326 self.enterOuterAlt(localctx, 1)
327 self.state = 72
328 self.if_stmt()
329 pass
330 elif token in [SimpleWorkflowParser.T__3]:
331 self.enterOuterAlt(localctx, 2)
332 self.state = 73
333 self.for_stmt()
334 pass
335 elif token in [SimpleWorkflowParser.T__1]:
336 self.enterOuterAlt(localctx, 3)
337 self.state = 74
338 self.affectation_stmt_comma()
339 pass
340 elif token in [SimpleWorkflowParser.T__26, SimpleWorkflowParser.Identifier]:
341 self.enterOuterAlt(localctx, 4)
342 self.state = 75
343 self.stmt_comma()
344 pass
345 else:
346 raise NoViableAltException(self)
348 except RecognitionException as re:
349 localctx.exception = re
350 self._errHandler.reportError(self, re)
351 self._errHandler.recover(self, re)
352 finally:
353 self.exitRule()
354 return localctx
356 class Affectation_stmt_commaContext(ParserRuleContext):
357 __slots__ = 'parser'
359 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
360 super().__init__(parent, invokingState)
361 self.parser = parser
363 def affectation_stmt(self):
364 return self.getTypedRuleContext(SimpleWorkflowParser.Affectation_stmtContext, 0)
366 def getRuleIndex(self):
367 return SimpleWorkflowParser.RULE_affectation_stmt_comma
369 def enterRule(self, listener: ParseTreeListener):
370 if hasattr(listener, "enterAffectation_stmt_comma"):
371 listener.enterAffectation_stmt_comma(self)
373 def exitRule(self, listener: ParseTreeListener):
374 if hasattr(listener, "exitAffectation_stmt_comma"):
375 listener.exitAffectation_stmt_comma(self)
377 def affectation_stmt_comma(self):
379 localctx = SimpleWorkflowParser.Affectation_stmt_commaContext(
380 self, self._ctx, self.state)
381 self.enterRule(localctx, 4, self.RULE_affectation_stmt_comma)
382 try:
383 self.enterOuterAlt(localctx, 1)
384 self.state = 78
385 self.affectation_stmt()
386 self.state = 79
387 self.match(SimpleWorkflowParser.T__0)
388 except RecognitionException as re:
389 localctx.exception = re
390 self._errHandler.reportError(self, re)
391 self._errHandler.recover(self, re)
392 finally:
393 self.exitRule()
394 return localctx
396 class Affectation_stmtContext(ParserRuleContext):
397 __slots__ = 'parser'
399 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
400 super().__init__(parent, invokingState)
401 self.parser = parser
403 def variable_name(self):
404 return self.getTypedRuleContext(SimpleWorkflowParser.Variable_nameContext, 0)
406 def expression(self):
407 return self.getTypedRuleContext(SimpleWorkflowParser.ExpressionContext, 0)
409 def getRuleIndex(self):
410 return SimpleWorkflowParser.RULE_affectation_stmt
412 def enterRule(self, listener: ParseTreeListener):
413 if hasattr(listener, "enterAffectation_stmt"):
414 listener.enterAffectation_stmt(self)
416 def exitRule(self, listener: ParseTreeListener):
417 if hasattr(listener, "exitAffectation_stmt"):
418 listener.exitAffectation_stmt(self)
420 def affectation_stmt(self):
422 localctx = SimpleWorkflowParser.Affectation_stmtContext(
423 self, self._ctx, self.state)
424 self.enterRule(localctx, 6, self.RULE_affectation_stmt)
425 try:
426 self.enterOuterAlt(localctx, 1)
427 self.state = 81
428 self.match(SimpleWorkflowParser.T__1)
429 self.state = 82
430 self.variable_name()
431 self.state = 83
432 self.match(SimpleWorkflowParser.T__2)
433 self.state = 84
434 self.expression()
435 except RecognitionException as re:
436 localctx.exception = re
437 self._errHandler.reportError(self, re)
438 self._errHandler.recover(self, re)
439 finally:
440 self.exitRule()
441 return localctx
443 class For_stmtContext(ParserRuleContext):
444 __slots__ = 'parser'
446 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
447 super().__init__(parent, invokingState)
448 self.parser = parser
450 def variable_name(self):
451 return self.getTypedRuleContext(SimpleWorkflowParser.Variable_nameContext, 0)
453 def function_call(self):
454 return self.getTypedRuleContext(SimpleWorkflowParser.Function_callContext, 0)
456 def final_stmt(self, i: int = None):
457 if i is None:
458 return self.getTypedRuleContexts(SimpleWorkflowParser.Final_stmtContext)
459 else:
460 return self.getTypedRuleContext(SimpleWorkflowParser.Final_stmtContext, i)
462 def getRuleIndex(self):
463 return SimpleWorkflowParser.RULE_for_stmt
465 def enterRule(self, listener: ParseTreeListener):
466 if hasattr(listener, "enterFor_stmt"):
467 listener.enterFor_stmt(self)
469 def exitRule(self, listener: ParseTreeListener):
470 if hasattr(listener, "exitFor_stmt"):
471 listener.exitFor_stmt(self)
473 def for_stmt(self):
475 localctx = SimpleWorkflowParser.For_stmtContext(
476 self, self._ctx, self.state)
477 self.enterRule(localctx, 8, self.RULE_for_stmt)
478 self._la = 0 # Token type
479 try:
480 self.enterOuterAlt(localctx, 1)
481 self.state = 86
482 self.match(SimpleWorkflowParser.T__3)
483 self.state = 87
484 self.match(SimpleWorkflowParser.T__4)
485 self.state = 88
486 self.variable_name()
487 self.state = 89
488 self.match(SimpleWorkflowParser.T__5)
489 self.state = 90
490 self.function_call()
491 self.state = 91
492 self.match(SimpleWorkflowParser.T__6)
493 self.state = 92
494 self.match(SimpleWorkflowParser.T__7)
495 self.state = 94
496 self._errHandler.sync(self)
497 _la = self._input.LA(1)
498 while True:
499 self.state = 93
500 self.final_stmt()
501 self.state = 96
502 self._errHandler.sync(self)
503 _la = self._input.LA(1)
504 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SimpleWorkflowParser.T__1) | (1 << SimpleWorkflowParser.T__3) | (1 << SimpleWorkflowParser.T__9) | (1 << SimpleWorkflowParser.T__26) | (1 << SimpleWorkflowParser.Identifier))) != 0)):
505 break
507 self.state = 98
508 self.match(SimpleWorkflowParser.T__8)
509 except RecognitionException as re:
510 localctx.exception = re
511 self._errHandler.reportError(self, re)
512 self._errHandler.recover(self, re)
513 finally:
514 self.exitRule()
515 return localctx
517 class If_stmtContext(ParserRuleContext):
518 __slots__ = 'parser'
520 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
521 super().__init__(parent, invokingState)
522 self.parser = parser
524 def expression(self):
525 return self.getTypedRuleContext(SimpleWorkflowParser.ExpressionContext, 0)
527 def final_stmt(self, i: int = None):
528 if i is None:
529 return self.getTypedRuleContexts(SimpleWorkflowParser.Final_stmtContext)
530 else:
531 return self.getTypedRuleContext(SimpleWorkflowParser.Final_stmtContext, i)
533 def getRuleIndex(self):
534 return SimpleWorkflowParser.RULE_if_stmt
536 def enterRule(self, listener: ParseTreeListener):
537 if hasattr(listener, "enterIf_stmt"):
538 listener.enterIf_stmt(self)
540 def exitRule(self, listener: ParseTreeListener):
541 if hasattr(listener, "exitIf_stmt"):
542 listener.exitIf_stmt(self)
544 def if_stmt(self):
546 localctx = SimpleWorkflowParser.If_stmtContext(
547 self, self._ctx, self.state)
548 self.enterRule(localctx, 10, self.RULE_if_stmt)
549 self._la = 0 # Token type
550 try:
551 self.enterOuterAlt(localctx, 1)
552 self.state = 100
553 self.match(SimpleWorkflowParser.T__9)
554 self.state = 101
555 self.match(SimpleWorkflowParser.T__4)
556 self.state = 102
557 self.expression()
558 self.state = 103
559 self.match(SimpleWorkflowParser.T__6)
560 self.state = 104
561 self.match(SimpleWorkflowParser.T__7)
562 self.state = 106
563 self._errHandler.sync(self)
564 _la = self._input.LA(1)
565 while True:
566 self.state = 105
567 self.final_stmt()
568 self.state = 108
569 self._errHandler.sync(self)
570 _la = self._input.LA(1)
571 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SimpleWorkflowParser.T__1) | (1 << SimpleWorkflowParser.T__3) | (1 << SimpleWorkflowParser.T__9) | (1 << SimpleWorkflowParser.T__26) | (1 << SimpleWorkflowParser.Identifier))) != 0)):
572 break
574 self.state = 110
575 self.match(SimpleWorkflowParser.T__8)
576 self.state = 120
577 self._errHandler.sync(self)
578 _la = self._input.LA(1)
579 if _la == SimpleWorkflowParser.T__10:
580 self.state = 111
581 self.match(SimpleWorkflowParser.T__10)
582 self.state = 112
583 self.match(SimpleWorkflowParser.T__7)
584 self.state = 114
585 self._errHandler.sync(self)
586 _la = self._input.LA(1)
587 while True:
588 self.state = 113
589 self.final_stmt()
590 self.state = 116
591 self._errHandler.sync(self)
592 _la = self._input.LA(1)
593 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SimpleWorkflowParser.T__1) | (1 << SimpleWorkflowParser.T__3) | (1 << SimpleWorkflowParser.T__9) | (1 << SimpleWorkflowParser.T__26) | (1 << SimpleWorkflowParser.Identifier))) != 0)):
594 break
596 self.state = 118
597 self.match(SimpleWorkflowParser.T__8)
599 except RecognitionException as re:
600 localctx.exception = re
601 self._errHandler.reportError(self, re)
602 self._errHandler.recover(self, re)
603 finally:
604 self.exitRule()
605 return localctx
607 class Evaluation_functionContext(ParserRuleContext):
608 __slots__ = 'parser'
610 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
611 super().__init__(parent, invokingState)
612 self.parser = parser
614 def Identifier(self):
615 return self.getToken(SimpleWorkflowParser.Identifier, 0)
617 def getRuleIndex(self):
618 return SimpleWorkflowParser.RULE_evaluation_function
620 def enterRule(self, listener: ParseTreeListener):
621 if hasattr(listener, "enterEvaluation_function"):
622 listener.enterEvaluation_function(self)
624 def exitRule(self, listener: ParseTreeListener):
625 if hasattr(listener, "exitEvaluation_function"):
626 listener.exitEvaluation_function(self)
628 def evaluation_function(self):
630 localctx = SimpleWorkflowParser.Evaluation_functionContext(
631 self, self._ctx, self.state)
632 self.enterRule(localctx, 12, self.RULE_evaluation_function)
633 try:
634 self.enterOuterAlt(localctx, 1)
635 self.state = 122
636 self.match(SimpleWorkflowParser.Identifier)
637 except RecognitionException as re:
638 localctx.exception = re
639 self._errHandler.reportError(self, re)
640 self._errHandler.recover(self, re)
641 finally:
642 self.exitRule()
643 return localctx
645 class ExpressionContext(ParserRuleContext):
646 __slots__ = 'parser'
648 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
649 super().__init__(parent, invokingState)
650 self.parser = parser
652 def expression_no_binary(self):
653 return self.getTypedRuleContext(SimpleWorkflowParser.Expression_no_binaryContext, 0)
655 def binary_operator(self):
656 return self.getTypedRuleContext(SimpleWorkflowParser.Binary_operatorContext, 0)
658 def expression(self):
659 return self.getTypedRuleContext(SimpleWorkflowParser.ExpressionContext, 0)
661 def getRuleIndex(self):
662 return SimpleWorkflowParser.RULE_expression
664 def enterRule(self, listener: ParseTreeListener):
665 if hasattr(listener, "enterExpression"):
666 listener.enterExpression(self)
668 def exitRule(self, listener: ParseTreeListener):
669 if hasattr(listener, "exitExpression"):
670 listener.exitExpression(self)
672 def expression(self):
674 localctx = SimpleWorkflowParser.ExpressionContext(
675 self, self._ctx, self.state)
676 self.enterRule(localctx, 14, self.RULE_expression)
677 try:
678 self.state = 129
679 self._errHandler.sync(self)
680 la_ = self._interp.adaptivePredict(self._input, 6, self._ctx)
681 if la_ == 1:
682 self.enterOuterAlt(localctx, 1)
683 self.state = 124
684 self.expression_no_binary()
685 pass
687 elif la_ == 2:
688 self.enterOuterAlt(localctx, 2)
689 self.state = 125
690 self.expression_no_binary()
691 self.state = 126
692 self.binary_operator()
693 self.state = 127
694 self.expression()
695 pass
697 except RecognitionException as re:
698 localctx.exception = re
699 self._errHandler.reportError(self, re)
700 self._errHandler.recover(self, re)
701 finally:
702 self.exitRule()
703 return localctx
705 class Expression_no_binaryContext(ParserRuleContext):
706 __slots__ = 'parser'
708 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
709 super().__init__(parent, invokingState)
710 self.parser = parser
712 def constant(self):
713 return self.getTypedRuleContext(SimpleWorkflowParser.ConstantContext, 0)
715 def variable_name(self):
716 return self.getTypedRuleContext(SimpleWorkflowParser.Variable_nameContext, 0)
718 def data_or_module_output(self):
719 return self.getTypedRuleContext(SimpleWorkflowParser.Data_or_module_outputContext, 0)
721 def expression(self):
722 return self.getTypedRuleContext(SimpleWorkflowParser.ExpressionContext, 0)
724 def unary_operator(self):
725 return self.getTypedRuleContext(SimpleWorkflowParser.Unary_operatorContext, 0)
727 def expression_no_binary(self):
728 return self.getTypedRuleContext(SimpleWorkflowParser.Expression_no_binaryContext, 0)
730 def function_call(self):
731 return self.getTypedRuleContext(SimpleWorkflowParser.Function_callContext, 0)
733 def getRuleIndex(self):
734 return SimpleWorkflowParser.RULE_expression_no_binary
736 def enterRule(self, listener: ParseTreeListener):
737 if hasattr(listener, "enterExpression_no_binary"):
738 listener.enterExpression_no_binary(self)
740 def exitRule(self, listener: ParseTreeListener):
741 if hasattr(listener, "exitExpression_no_binary"):
742 listener.exitExpression_no_binary(self)
744 def expression_no_binary(self):
746 localctx = SimpleWorkflowParser.Expression_no_binaryContext(
747 self, self._ctx, self.state)
748 self.enterRule(localctx, 16, self.RULE_expression_no_binary)
749 try:
750 self.state = 142
751 self._errHandler.sync(self)
752 la_ = self._interp.adaptivePredict(self._input, 7, self._ctx)
753 if la_ == 1:
754 self.enterOuterAlt(localctx, 1)
755 self.state = 131
756 self.constant()
757 pass
759 elif la_ == 2:
760 self.enterOuterAlt(localctx, 2)
761 self.state = 132
762 self.variable_name()
763 pass
765 elif la_ == 3:
766 self.enterOuterAlt(localctx, 3)
767 self.state = 133
768 self.data_or_module_output()
769 pass
771 elif la_ == 4:
772 self.enterOuterAlt(localctx, 4)
773 self.state = 134
774 self.match(SimpleWorkflowParser.T__4)
775 self.state = 135
776 self.expression()
777 self.state = 136
778 self.match(SimpleWorkflowParser.T__6)
779 pass
781 elif la_ == 5:
782 self.enterOuterAlt(localctx, 5)
783 self.state = 138
784 self.unary_operator()
785 self.state = 139
786 self.expression_no_binary()
787 pass
789 elif la_ == 6:
790 self.enterOuterAlt(localctx, 6)
791 self.state = 141
792 self.function_call()
793 pass
795 except RecognitionException as re:
796 localctx.exception = re
797 self._errHandler.reportError(self, re)
798 self._errHandler.recover(self, re)
799 finally:
800 self.exitRule()
801 return localctx
803 class Function_callContext(ParserRuleContext):
804 __slots__ = 'parser'
806 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
807 super().__init__(parent, invokingState)
808 self.parser = parser
810 def evaluation_function(self):
811 return self.getTypedRuleContext(SimpleWorkflowParser.Evaluation_functionContext, 0)
813 def expression(self, i: int = None):
814 if i is None:
815 return self.getTypedRuleContexts(SimpleWorkflowParser.ExpressionContext)
816 else:
817 return self.getTypedRuleContext(SimpleWorkflowParser.ExpressionContext, i)
819 def getRuleIndex(self):
820 return SimpleWorkflowParser.RULE_function_call
822 def enterRule(self, listener: ParseTreeListener):
823 if hasattr(listener, "enterFunction_call"):
824 listener.enterFunction_call(self)
826 def exitRule(self, listener: ParseTreeListener):
827 if hasattr(listener, "exitFunction_call"):
828 listener.exitFunction_call(self)
830 def function_call(self):
832 localctx = SimpleWorkflowParser.Function_callContext(
833 self, self._ctx, self.state)
834 self.enterRule(localctx, 18, self.RULE_function_call)
835 self._la = 0 # Token type
836 try:
837 self.enterOuterAlt(localctx, 1)
838 self.state = 144
839 self.evaluation_function()
840 self.state = 145
841 self.match(SimpleWorkflowParser.T__4)
842 self.state = 147
843 self._errHandler.sync(self)
844 _la = self._input.LA(1)
845 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SimpleWorkflowParser.T__4) | (1 << SimpleWorkflowParser.T__12) | (1 << SimpleWorkflowParser.T__13) | (1 << SimpleWorkflowParser.T__25) | (1 << SimpleWorkflowParser.Digits) | (1 << SimpleWorkflowParser.Identifier) | (1 << SimpleWorkflowParser.Sign) | (1 << SimpleWorkflowParser.STRING))) != 0):
846 self.state = 146
847 self.expression()
849 self.state = 153
850 self._errHandler.sync(self)
851 _la = self._input.LA(1)
852 while _la == SimpleWorkflowParser.T__11:
853 self.state = 149
854 self.match(SimpleWorkflowParser.T__11)
855 self.state = 150
856 self.expression()
857 self.state = 155
858 self._errHandler.sync(self)
859 _la = self._input.LA(1)
861 self.state = 156
862 self.match(SimpleWorkflowParser.T__6)
863 except RecognitionException as re:
864 localctx.exception = re
865 self._errHandler.reportError(self, re)
866 self._errHandler.recover(self, re)
867 finally:
868 self.exitRule()
869 return localctx
871 class Variable_nameContext(ParserRuleContext):
872 __slots__ = 'parser'
874 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
875 super().__init__(parent, invokingState)
876 self.parser = parser
878 def Identifier(self):
879 return self.getToken(SimpleWorkflowParser.Identifier, 0)
881 def getRuleIndex(self):
882 return SimpleWorkflowParser.RULE_variable_name
884 def enterRule(self, listener: ParseTreeListener):
885 if hasattr(listener, "enterVariable_name"):
886 listener.enterVariable_name(self)
888 def exitRule(self, listener: ParseTreeListener):
889 if hasattr(listener, "exitVariable_name"):
890 listener.exitVariable_name(self)
892 def variable_name(self):
894 localctx = SimpleWorkflowParser.Variable_nameContext(
895 self, self._ctx, self.state)
896 self.enterRule(localctx, 20, self.RULE_variable_name)
897 try:
898 self.enterOuterAlt(localctx, 1)
899 self.state = 158
900 self.match(SimpleWorkflowParser.Identifier)
901 except RecognitionException as re:
902 localctx.exception = re
903 self._errHandler.reportError(self, re)
904 self._errHandler.recover(self, re)
905 finally:
906 self.exitRule()
907 return localctx
909 class Binary_operatorContext(ParserRuleContext):
910 __slots__ = 'parser'
912 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
913 super().__init__(parent, invokingState)
914 self.parser = parser
916 def getRuleIndex(self):
917 return SimpleWorkflowParser.RULE_binary_operator
919 def enterRule(self, listener: ParseTreeListener):
920 if hasattr(listener, "enterBinary_operator"):
921 listener.enterBinary_operator(self)
923 def exitRule(self, listener: ParseTreeListener):
924 if hasattr(listener, "exitBinary_operator"):
925 listener.exitBinary_operator(self)
927 def binary_operator(self):
929 localctx = SimpleWorkflowParser.Binary_operatorContext(
930 self, self._ctx, self.state)
931 self.enterRule(localctx, 22, self.RULE_binary_operator)
932 self._la = 0 # Token type
933 try:
934 self.enterOuterAlt(localctx, 1)
935 self.state = 160
936 _la = self._input.LA(1)
937 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SimpleWorkflowParser.T__12) | (1 << SimpleWorkflowParser.T__13) | (1 << SimpleWorkflowParser.T__14) | (1 << SimpleWorkflowParser.T__15) | (1 << SimpleWorkflowParser.T__16) | (1 << SimpleWorkflowParser.T__17) | (1 << SimpleWorkflowParser.T__18) | (1 << SimpleWorkflowParser.T__19) | (1 << SimpleWorkflowParser.T__20) | (1 << SimpleWorkflowParser.T__21) | (1 << SimpleWorkflowParser.T__22) | (1 << SimpleWorkflowParser.T__23) | (1 << SimpleWorkflowParser.T__24))) != 0)):
938 self._errHandler.recoverInline(self)
939 else:
940 self._errHandler.reportMatch(self)
941 self.consume()
942 except RecognitionException as re:
943 localctx.exception = re
944 self._errHandler.reportError(self, re)
945 self._errHandler.recover(self, re)
946 finally:
947 self.exitRule()
948 return localctx
950 class Unary_operatorContext(ParserRuleContext):
951 __slots__ = 'parser'
953 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
954 super().__init__(parent, invokingState)
955 self.parser = parser
957 def getRuleIndex(self):
958 return SimpleWorkflowParser.RULE_unary_operator
960 def enterRule(self, listener: ParseTreeListener):
961 if hasattr(listener, "enterUnary_operator"):
962 listener.enterUnary_operator(self)
964 def exitRule(self, listener: ParseTreeListener):
965 if hasattr(listener, "exitUnary_operator"):
966 listener.exitUnary_operator(self)
968 def unary_operator(self):
970 localctx = SimpleWorkflowParser.Unary_operatorContext(
971 self, self._ctx, self.state)
972 self.enterRule(localctx, 24, self.RULE_unary_operator)
973 self._la = 0 # Token type
974 try:
975 self.enterOuterAlt(localctx, 1)
976 self.state = 162
977 _la = self._input.LA(1)
978 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SimpleWorkflowParser.T__12) | (1 << SimpleWorkflowParser.T__13) | (1 << SimpleWorkflowParser.T__25))) != 0)):
979 self._errHandler.recoverInline(self)
980 else:
981 self._errHandler.reportMatch(self)
982 self.consume()
983 except RecognitionException as re:
984 localctx.exception = re
985 self._errHandler.reportError(self, re)
986 self._errHandler.recover(self, re)
987 finally:
988 self.exitRule()
989 return localctx
991 class Stmt_commaContext(ParserRuleContext):
992 __slots__ = 'parser'
994 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
995 super().__init__(parent, invokingState)
996 self.parser = parser
998 def stmt(self):
999 return self.getTypedRuleContext(SimpleWorkflowParser.StmtContext, 0)
1001 def getRuleIndex(self):
1002 return SimpleWorkflowParser.RULE_stmt_comma
1004 def enterRule(self, listener: ParseTreeListener):
1005 if hasattr(listener, "enterStmt_comma"):
1006 listener.enterStmt_comma(self)
1008 def exitRule(self, listener: ParseTreeListener):
1009 if hasattr(listener, "exitStmt_comma"):
1010 listener.exitStmt_comma(self)
1012 def stmt_comma(self):
1014 localctx = SimpleWorkflowParser.Stmt_commaContext(
1015 self, self._ctx, self.state)
1016 self.enterRule(localctx, 26, self.RULE_stmt_comma)
1017 try:
1018 self.enterOuterAlt(localctx, 1)
1019 self.state = 164
1020 self.stmt()
1021 self.state = 165
1022 self.match(SimpleWorkflowParser.T__0)
1023 except RecognitionException as re:
1024 localctx.exception = re
1025 self._errHandler.reportError(self, re)
1026 self._errHandler.recover(self, re)
1027 finally:
1028 self.exitRule()
1029 return localctx
1031 class StmtContext(ParserRuleContext):
1032 __slots__ = 'parser'
1034 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1035 super().__init__(parent, invokingState)
1036 self.parser = parser
1038 def connect_stmt(self):
1039 return self.getTypedRuleContext(SimpleWorkflowParser.Connect_stmtContext, 0)
1041 def data_stmt(self):
1042 return self.getTypedRuleContext(SimpleWorkflowParser.Data_stmtContext, 0)
1044 def module_stmt(self):
1045 return self.getTypedRuleContext(SimpleWorkflowParser.Module_stmtContext, 0)
1047 def getRuleIndex(self):
1048 return SimpleWorkflowParser.RULE_stmt
1050 def enterRule(self, listener: ParseTreeListener):
1051 if hasattr(listener, "enterStmt"):
1052 listener.enterStmt(self)
1054 def exitRule(self, listener: ParseTreeListener):
1055 if hasattr(listener, "exitStmt"):
1056 listener.exitStmt(self)
1058 def stmt(self):
1060 localctx = SimpleWorkflowParser.StmtContext(
1061 self, self._ctx, self.state)
1062 self.enterRule(localctx, 28, self.RULE_stmt)
1063 try:
1064 self.state = 170
1065 self._errHandler.sync(self)
1066 la_ = self._interp.adaptivePredict(self._input, 10, self._ctx)
1067 if la_ == 1:
1068 self.enterOuterAlt(localctx, 1)
1069 self.state = 167
1070 self.connect_stmt()
1071 pass
1073 elif la_ == 2:
1074 self.enterOuterAlt(localctx, 2)
1075 self.state = 168
1076 self.data_stmt()
1077 pass
1079 elif la_ == 3:
1080 self.enterOuterAlt(localctx, 3)
1081 self.state = 169
1082 self.module_stmt()
1083 pass
1085 except RecognitionException as re:
1086 localctx.exception = re
1087 self._errHandler.reportError(self, re)
1088 self._errHandler.recover(self, re)
1089 finally:
1090 self.exitRule()
1091 return localctx
1093 class Connect_stmtContext(ParserRuleContext):
1094 __slots__ = 'parser'
1096 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1097 super().__init__(parent, invokingState)
1098 self.parser = parser
1100 def data_or_module_output(self):
1101 return self.getTypedRuleContext(SimpleWorkflowParser.Data_or_module_outputContext, 0)
1103 def module_input(self):
1104 return self.getTypedRuleContext(SimpleWorkflowParser.Module_inputContext, 0)
1106 def getRuleIndex(self):
1107 return SimpleWorkflowParser.RULE_connect_stmt
1109 def enterRule(self, listener: ParseTreeListener):
1110 if hasattr(listener, "enterConnect_stmt"):
1111 listener.enterConnect_stmt(self)
1113 def exitRule(self, listener: ParseTreeListener):
1114 if hasattr(listener, "exitConnect_stmt"):
1115 listener.exitConnect_stmt(self)
1117 def connect_stmt(self):
1119 localctx = SimpleWorkflowParser.Connect_stmtContext(
1120 self, self._ctx, self.state)
1121 self.enterRule(localctx, 30, self.RULE_connect_stmt)
1122 self._la = 0 # Token type
1123 try:
1124 self.state = 184
1125 self._errHandler.sync(self)
1126 la_ = self._interp.adaptivePredict(self._input, 11, self._ctx)
1127 if la_ == 1:
1128 self.enterOuterAlt(localctx, 1)
1129 self.state = 172
1130 self.match(SimpleWorkflowParser.T__26)
1131 self.state = 173
1132 self.data_or_module_output()
1133 self.state = 174
1134 _la = self._input.LA(1)
1135 if not (_la == SimpleWorkflowParser.T__27 or _la == SimpleWorkflowParser.T__28):
1136 self._errHandler.recoverInline(self)
1137 else:
1138 self._errHandler.reportMatch(self)
1139 self.consume()
1140 self.state = 175
1141 self.module_input()
1142 pass
1144 elif la_ == 2:
1145 self.enterOuterAlt(localctx, 2)
1146 self.state = 177
1147 self.match(SimpleWorkflowParser.T__26)
1148 self.state = 178
1149 self.match(SimpleWorkflowParser.T__4)
1150 self.state = 179
1151 self.data_or_module_output()
1152 self.state = 180
1153 self.match(SimpleWorkflowParser.T__11)
1154 self.state = 181
1155 self.module_input()
1156 self.state = 182
1157 self.match(SimpleWorkflowParser.T__6)
1158 pass
1160 except RecognitionException as re:
1161 localctx.exception = re
1162 self._errHandler.reportError(self, re)
1163 self._errHandler.recover(self, re)
1164 finally:
1165 self.exitRule()
1166 return localctx
1168 class Data_or_module_outputContext(ParserRuleContext):
1169 __slots__ = 'parser'
1171 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1172 super().__init__(parent, invokingState)
1173 self.parser = parser
1175 def element_name(self):
1176 return self.getTypedRuleContext(SimpleWorkflowParser.Element_nameContext, 0)
1178 def inout_name(self):
1179 return self.getTypedRuleContext(SimpleWorkflowParser.Inout_nameContext, 0)
1181 def getRuleIndex(self):
1182 return SimpleWorkflowParser.RULE_data_or_module_output
1184 def enterRule(self, listener: ParseTreeListener):
1185 if hasattr(listener, "enterData_or_module_output"):
1186 listener.enterData_or_module_output(self)
1188 def exitRule(self, listener: ParseTreeListener):
1189 if hasattr(listener, "exitData_or_module_output"):
1190 listener.exitData_or_module_output(self)
1192 def data_or_module_output(self):
1194 localctx = SimpleWorkflowParser.Data_or_module_outputContext(
1195 self, self._ctx, self.state)
1196 self.enterRule(localctx, 32, self.RULE_data_or_module_output)
1197 self._la = 0 # Token type
1198 try:
1199 self.enterOuterAlt(localctx, 1)
1200 self.state = 186
1201 self.element_name()
1202 self.state = 189
1203 self._errHandler.sync(self)
1204 _la = self._input.LA(1)
1205 if _la == SimpleWorkflowParser.T__29:
1206 self.state = 187
1207 self.match(SimpleWorkflowParser.T__29)
1208 self.state = 188
1209 self.inout_name()
1211 except RecognitionException as re:
1212 localctx.exception = re
1213 self._errHandler.reportError(self, re)
1214 self._errHandler.recover(self, re)
1215 finally:
1216 self.exitRule()
1217 return localctx
1219 class Module_inputContext(ParserRuleContext):
1220 __slots__ = 'parser'
1222 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1223 super().__init__(parent, invokingState)
1224 self.parser = parser
1226 def element_name(self):
1227 return self.getTypedRuleContext(SimpleWorkflowParser.Element_nameContext, 0)
1229 def inout_name(self):
1230 return self.getTypedRuleContext(SimpleWorkflowParser.Inout_nameContext, 0)
1232 def getRuleIndex(self):
1233 return SimpleWorkflowParser.RULE_module_input
1235 def enterRule(self, listener: ParseTreeListener):
1236 if hasattr(listener, "enterModule_input"):
1237 listener.enterModule_input(self)
1239 def exitRule(self, listener: ParseTreeListener):
1240 if hasattr(listener, "exitModule_input"):
1241 listener.exitModule_input(self)
1243 def module_input(self):
1245 localctx = SimpleWorkflowParser.Module_inputContext(
1246 self, self._ctx, self.state)
1247 self.enterRule(localctx, 34, self.RULE_module_input)
1248 self._la = 0 # Token type
1249 try:
1250 self.enterOuterAlt(localctx, 1)
1251 self.state = 191
1252 self.element_name()
1253 self.state = 194
1254 self._errHandler.sync(self)
1255 _la = self._input.LA(1)
1256 if _la == SimpleWorkflowParser.T__29:
1257 self.state = 192
1258 self.match(SimpleWorkflowParser.T__29)
1259 self.state = 193
1260 self.inout_name()
1262 except RecognitionException as re:
1263 localctx.exception = re
1264 self._errHandler.reportError(self, re)
1265 self._errHandler.recover(self, re)
1266 finally:
1267 self.exitRule()
1268 return localctx
1270 class Data_stmtContext(ParserRuleContext):
1271 __slots__ = 'parser'
1273 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1274 super().__init__(parent, invokingState)
1275 self.parser = parser
1277 def element_name(self):
1278 return self.getTypedRuleContext(SimpleWorkflowParser.Element_nameContext, 0)
1280 def data_name(self):
1281 return self.getTypedRuleContext(SimpleWorkflowParser.Data_nameContext, 0)
1283 def getRuleIndex(self):
1284 return SimpleWorkflowParser.RULE_data_stmt
1286 def enterRule(self, listener: ParseTreeListener):
1287 if hasattr(listener, "enterData_stmt"):
1288 listener.enterData_stmt(self)
1290 def exitRule(self, listener: ParseTreeListener):
1291 if hasattr(listener, "exitData_stmt"):
1292 listener.exitData_stmt(self)
1294 def data_stmt(self):
1296 localctx = SimpleWorkflowParser.Data_stmtContext(
1297 self, self._ctx, self.state)
1298 self.enterRule(localctx, 36, self.RULE_data_stmt)
1299 try:
1300 self.enterOuterAlt(localctx, 1)
1301 self.state = 196
1302 self.element_name()
1303 self.state = 197
1304 self.match(SimpleWorkflowParser.T__2)
1305 self.state = 198
1306 self.data_name()
1307 except RecognitionException as re:
1308 localctx.exception = re
1309 self._errHandler.reportError(self, re)
1310 self._errHandler.recover(self, re)
1311 finally:
1312 self.exitRule()
1313 return localctx
1315 class Module_stmtContext(ParserRuleContext):
1316 __slots__ = 'parser'
1318 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1319 super().__init__(parent, invokingState)
1320 self.parser = parser
1322 def element_name(self):
1323 return self.getTypedRuleContext(SimpleWorkflowParser.Element_nameContext, 0)
1325 def module_call(self):
1326 return self.getTypedRuleContext(SimpleWorkflowParser.Module_callContext, 0)
1328 def getRuleIndex(self):
1329 return SimpleWorkflowParser.RULE_module_stmt
1331 def enterRule(self, listener: ParseTreeListener):
1332 if hasattr(listener, "enterModule_stmt"):
1333 listener.enterModule_stmt(self)
1335 def exitRule(self, listener: ParseTreeListener):
1336 if hasattr(listener, "exitModule_stmt"):
1337 listener.exitModule_stmt(self)
1339 def module_stmt(self):
1341 localctx = SimpleWorkflowParser.Module_stmtContext(
1342 self, self._ctx, self.state)
1343 self.enterRule(localctx, 38, self.RULE_module_stmt)
1344 try:
1345 self.enterOuterAlt(localctx, 1)
1346 self.state = 200
1347 self.element_name()
1348 self.state = 201
1349 self.match(SimpleWorkflowParser.T__2)
1350 self.state = 202
1351 self.module_call()
1352 except RecognitionException as re:
1353 localctx.exception = re
1354 self._errHandler.reportError(self, re)
1355 self._errHandler.recover(self, re)
1356 finally:
1357 self.exitRule()
1358 return localctx
1360 class Module_callContext(ParserRuleContext):
1361 __slots__ = 'parser'
1363 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1364 super().__init__(parent, invokingState)
1365 self.parser = parser
1367 def module_name(self):
1368 return self.getTypedRuleContext(SimpleWorkflowParser.Module_nameContext, 0)
1370 def list_param_affectation(self):
1371 return self.getTypedRuleContext(SimpleWorkflowParser.List_param_affectationContext, 0)
1373 def getRuleIndex(self):
1374 return SimpleWorkflowParser.RULE_module_call
1376 def enterRule(self, listener: ParseTreeListener):
1377 if hasattr(listener, "enterModule_call"):
1378 listener.enterModule_call(self)
1380 def exitRule(self, listener: ParseTreeListener):
1381 if hasattr(listener, "exitModule_call"):
1382 listener.exitModule_call(self)
1384 def module_call(self):
1386 localctx = SimpleWorkflowParser.Module_callContext(
1387 self, self._ctx, self.state)
1388 self.enterRule(localctx, 40, self.RULE_module_call)
1389 try:
1390 self.enterOuterAlt(localctx, 1)
1391 self.state = 204
1392 self.module_name()
1393 self.state = 205
1394 self.match(SimpleWorkflowParser.T__4)
1395 self.state = 206
1396 self.list_param_affectation()
1397 self.state = 207
1398 self.match(SimpleWorkflowParser.T__6)
1399 except RecognitionException as re:
1400 localctx.exception = re
1401 self._errHandler.reportError(self, re)
1402 self._errHandler.recover(self, re)
1403 finally:
1404 self.exitRule()
1405 return localctx
1407 class Element_nameContext(ParserRuleContext):
1408 __slots__ = 'parser'
1410 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1411 super().__init__(parent, invokingState)
1412 self.parser = parser
1414 def Identifier(self):
1415 return self.getToken(SimpleWorkflowParser.Identifier, 0)
1417 def getRuleIndex(self):
1418 return SimpleWorkflowParser.RULE_element_name
1420 def enterRule(self, listener: ParseTreeListener):
1421 if hasattr(listener, "enterElement_name"):
1422 listener.enterElement_name(self)
1424 def exitRule(self, listener: ParseTreeListener):
1425 if hasattr(listener, "exitElement_name"):
1426 listener.exitElement_name(self)
1428 def element_name(self):
1430 localctx = SimpleWorkflowParser.Element_nameContext(
1431 self, self._ctx, self.state)
1432 self.enterRule(localctx, 42, self.RULE_element_name)
1433 try:
1434 self.enterOuterAlt(localctx, 1)
1435 self.state = 209
1436 self.match(SimpleWorkflowParser.Identifier)
1437 except RecognitionException as re:
1438 localctx.exception = re
1439 self._errHandler.reportError(self, re)
1440 self._errHandler.recover(self, re)
1441 finally:
1442 self.exitRule()
1443 return localctx
1445 class List_param_affectationContext(ParserRuleContext):
1446 __slots__ = 'parser'
1448 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1449 super().__init__(parent, invokingState)
1450 self.parser = parser
1452 def param_affectation(self, i: int = None):
1453 if i is None:
1454 return self.getTypedRuleContexts(SimpleWorkflowParser.Param_affectationContext)
1455 else:
1456 return self.getTypedRuleContext(SimpleWorkflowParser.Param_affectationContext, i)
1458 def getRuleIndex(self):
1459 return SimpleWorkflowParser.RULE_list_param_affectation
1461 def enterRule(self, listener: ParseTreeListener):
1462 if hasattr(listener, "enterList_param_affectation"):
1463 listener.enterList_param_affectation(self)
1465 def exitRule(self, listener: ParseTreeListener):
1466 if hasattr(listener, "exitList_param_affectation"):
1467 listener.exitList_param_affectation(self)
1469 def list_param_affectation(self):
1471 localctx = SimpleWorkflowParser.List_param_affectationContext(
1472 self, self._ctx, self.state)
1473 self.enterRule(localctx, 44, self.RULE_list_param_affectation)
1474 self._la = 0 # Token type
1475 try:
1476 self.enterOuterAlt(localctx, 1)
1477 self.state = 212
1478 self._errHandler.sync(self)
1479 _la = self._input.LA(1)
1480 if _la == SimpleWorkflowParser.Identifier:
1481 self.state = 211
1482 self.param_affectation()
1484 self.state = 218
1485 self._errHandler.sync(self)
1486 _la = self._input.LA(1)
1487 while _la == SimpleWorkflowParser.T__11:
1488 self.state = 214
1489 self.match(SimpleWorkflowParser.T__11)
1490 self.state = 215
1491 self.param_affectation()
1492 self.state = 220
1493 self._errHandler.sync(self)
1494 _la = self._input.LA(1)
1496 except RecognitionException as re:
1497 localctx.exception = re
1498 self._errHandler.reportError(self, re)
1499 self._errHandler.recover(self, re)
1500 finally:
1501 self.exitRule()
1502 return localctx
1504 class Param_affectationContext(ParserRuleContext):
1505 __slots__ = 'parser'
1507 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1508 super().__init__(parent, invokingState)
1509 self.parser = parser
1511 def param_name(self):
1512 return self.getTypedRuleContext(SimpleWorkflowParser.Param_nameContext, 0)
1514 def expression(self):
1515 return self.getTypedRuleContext(SimpleWorkflowParser.ExpressionContext, 0)
1517 def getRuleIndex(self):
1518 return SimpleWorkflowParser.RULE_param_affectation
1520 def enterRule(self, listener: ParseTreeListener):
1521 if hasattr(listener, "enterParam_affectation"):
1522 listener.enterParam_affectation(self)
1524 def exitRule(self, listener: ParseTreeListener):
1525 if hasattr(listener, "exitParam_affectation"):
1526 listener.exitParam_affectation(self)
1528 def param_affectation(self):
1530 localctx = SimpleWorkflowParser.Param_affectationContext(
1531 self, self._ctx, self.state)
1532 self.enterRule(localctx, 46, self.RULE_param_affectation)
1533 try:
1534 self.enterOuterAlt(localctx, 1)
1535 self.state = 221
1536 self.param_name()
1537 self.state = 222
1538 self.match(SimpleWorkflowParser.T__2)
1539 self.state = 223
1540 self.expression()
1541 except RecognitionException as re:
1542 localctx.exception = re
1543 self._errHandler.reportError(self, re)
1544 self._errHandler.recover(self, re)
1545 finally:
1546 self.exitRule()
1547 return localctx
1549 class Param_nameContext(ParserRuleContext):
1550 __slots__ = 'parser'
1552 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1553 super().__init__(parent, invokingState)
1554 self.parser = parser
1556 def Identifier(self):
1557 return self.getToken(SimpleWorkflowParser.Identifier, 0)
1559 def getRuleIndex(self):
1560 return SimpleWorkflowParser.RULE_param_name
1562 def enterRule(self, listener: ParseTreeListener):
1563 if hasattr(listener, "enterParam_name"):
1564 listener.enterParam_name(self)
1566 def exitRule(self, listener: ParseTreeListener):
1567 if hasattr(listener, "exitParam_name"):
1568 listener.exitParam_name(self)
1570 def param_name(self):
1572 localctx = SimpleWorkflowParser.Param_nameContext(
1573 self, self._ctx, self.state)
1574 self.enterRule(localctx, 48, self.RULE_param_name)
1575 try:
1576 self.enterOuterAlt(localctx, 1)
1577 self.state = 225
1578 self.match(SimpleWorkflowParser.Identifier)
1579 except RecognitionException as re:
1580 localctx.exception = re
1581 self._errHandler.reportError(self, re)
1582 self._errHandler.recover(self, re)
1583 finally:
1584 self.exitRule()
1585 return localctx
1587 class Inout_nameContext(ParserRuleContext):
1588 __slots__ = 'parser'
1590 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1591 super().__init__(parent, invokingState)
1592 self.parser = parser
1594 def Identifier(self):
1595 return self.getToken(SimpleWorkflowParser.Identifier, 0)
1597 def getRuleIndex(self):
1598 return SimpleWorkflowParser.RULE_inout_name
1600 def enterRule(self, listener: ParseTreeListener):
1601 if hasattr(listener, "enterInout_name"):
1602 listener.enterInout_name(self)
1604 def exitRule(self, listener: ParseTreeListener):
1605 if hasattr(listener, "exitInout_name"):
1606 listener.exitInout_name(self)
1608 def inout_name(self):
1610 localctx = SimpleWorkflowParser.Inout_nameContext(
1611 self, self._ctx, self.state)
1612 self.enterRule(localctx, 50, self.RULE_inout_name)
1613 try:
1614 self.enterOuterAlt(localctx, 1)
1615 self.state = 227
1616 self.match(SimpleWorkflowParser.Identifier)
1617 except RecognitionException as re:
1618 localctx.exception = re
1619 self._errHandler.reportError(self, re)
1620 self._errHandler.recover(self, re)
1621 finally:
1622 self.exitRule()
1623 return localctx
1625 class Module_nameContext(ParserRuleContext):
1626 __slots__ = 'parser'
1628 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1629 super().__init__(parent, invokingState)
1630 self.parser = parser
1632 def Identifier(self):
1633 return self.getToken(SimpleWorkflowParser.Identifier, 0)
1635 def STRING(self):
1636 return self.getToken(SimpleWorkflowParser.STRING, 0)
1638 def getRuleIndex(self):
1639 return SimpleWorkflowParser.RULE_module_name
1641 def enterRule(self, listener: ParseTreeListener):
1642 if hasattr(listener, "enterModule_name"):
1643 listener.enterModule_name(self)
1645 def exitRule(self, listener: ParseTreeListener):
1646 if hasattr(listener, "exitModule_name"):
1647 listener.exitModule_name(self)
1649 def module_name(self):
1651 localctx = SimpleWorkflowParser.Module_nameContext(
1652 self, self._ctx, self.state)
1653 self.enterRule(localctx, 52, self.RULE_module_name)
1654 self._la = 0 # Token type
1655 try:
1656 self.enterOuterAlt(localctx, 1)
1657 self.state = 229
1658 self.match(SimpleWorkflowParser.T__30)
1659 self.state = 230
1660 self.match(SimpleWorkflowParser.T__29)
1661 self.state = 231
1662 _la = self._input.LA(1)
1663 if not (_la == SimpleWorkflowParser.Identifier or _la == SimpleWorkflowParser.STRING):
1664 self._errHandler.recoverInline(self)
1665 else:
1666 self._errHandler.reportMatch(self)
1667 self.consume()
1668 except RecognitionException as re:
1669 localctx.exception = re
1670 self._errHandler.reportError(self, re)
1671 self._errHandler.recover(self, re)
1672 finally:
1673 self.exitRule()
1674 return localctx
1676 class Data_nameContext(ParserRuleContext):
1677 __slots__ = 'parser'
1679 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1680 super().__init__(parent, invokingState)
1681 self.parser = parser
1683 def Identifier(self):
1684 return self.getToken(SimpleWorkflowParser.Identifier, 0)
1686 def STRING(self):
1687 return self.getToken(SimpleWorkflowParser.STRING, 0)
1689 def getRuleIndex(self):
1690 return SimpleWorkflowParser.RULE_data_name
1692 def enterRule(self, listener: ParseTreeListener):
1693 if hasattr(listener, "enterData_name"):
1694 listener.enterData_name(self)
1696 def exitRule(self, listener: ParseTreeListener):
1697 if hasattr(listener, "exitData_name"):
1698 listener.exitData_name(self)
1700 def data_name(self):
1702 localctx = SimpleWorkflowParser.Data_nameContext(
1703 self, self._ctx, self.state)
1704 self.enterRule(localctx, 54, self.RULE_data_name)
1705 self._la = 0 # Token type
1706 try:
1707 self.enterOuterAlt(localctx, 1)
1708 self.state = 233
1709 self.match(SimpleWorkflowParser.T__31)
1710 self.state = 234
1711 self.match(SimpleWorkflowParser.T__29)
1712 self.state = 235
1713 _la = self._input.LA(1)
1714 if not (_la == SimpleWorkflowParser.Identifier or _la == SimpleWorkflowParser.STRING):
1715 self._errHandler.recoverInline(self)
1716 else:
1717 self._errHandler.reportMatch(self)
1718 self.consume()
1719 except RecognitionException as re:
1720 localctx.exception = re
1721 self._errHandler.reportError(self, re)
1722 self._errHandler.recover(self, re)
1723 finally:
1724 self.exitRule()
1725 return localctx
1727 class ConstantContext(ParserRuleContext):
1728 __slots__ = 'parser'
1730 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1731 super().__init__(parent, invokingState)
1732 self.parser = parser
1734 def integer_number(self):
1735 return self.getTypedRuleContext(SimpleWorkflowParser.Integer_numberContext, 0)
1737 def real_number(self):
1738 return self.getTypedRuleContext(SimpleWorkflowParser.Real_numberContext, 0)
1740 def string_literal(self):
1741 return self.getTypedRuleContext(SimpleWorkflowParser.String_literalContext, 0)
1743 def getRuleIndex(self):
1744 return SimpleWorkflowParser.RULE_constant
1746 def enterRule(self, listener: ParseTreeListener):
1747 if hasattr(listener, "enterConstant"):
1748 listener.enterConstant(self)
1750 def exitRule(self, listener: ParseTreeListener):
1751 if hasattr(listener, "exitConstant"):
1752 listener.exitConstant(self)
1754 def constant(self):
1756 localctx = SimpleWorkflowParser.ConstantContext(
1757 self, self._ctx, self.state)
1758 self.enterRule(localctx, 56, self.RULE_constant)
1759 try:
1760 self.state = 240
1761 self._errHandler.sync(self)
1762 la_ = self._interp.adaptivePredict(self._input, 16, self._ctx)
1763 if la_ == 1:
1764 self.enterOuterAlt(localctx, 1)
1765 self.state = 237
1766 self.integer_number()
1767 pass
1769 elif la_ == 2:
1770 self.enterOuterAlt(localctx, 2)
1771 self.state = 238
1772 self.real_number()
1773 pass
1775 elif la_ == 3:
1776 self.enterOuterAlt(localctx, 3)
1777 self.state = 239
1778 self.string_literal()
1779 pass
1781 except RecognitionException as re:
1782 localctx.exception = re
1783 self._errHandler.reportError(self, re)
1784 self._errHandler.recover(self, re)
1785 finally:
1786 self.exitRule()
1787 return localctx
1789 class String_literalContext(ParserRuleContext):
1790 __slots__ = 'parser'
1792 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1793 super().__init__(parent, invokingState)
1794 self.parser = parser
1796 def STRING(self):
1797 return self.getToken(SimpleWorkflowParser.STRING, 0)
1799 def getRuleIndex(self):
1800 return SimpleWorkflowParser.RULE_string_literal
1802 def enterRule(self, listener: ParseTreeListener):
1803 if hasattr(listener, "enterString_literal"):
1804 listener.enterString_literal(self)
1806 def exitRule(self, listener: ParseTreeListener):
1807 if hasattr(listener, "exitString_literal"):
1808 listener.exitString_literal(self)
1810 def string_literal(self):
1812 localctx = SimpleWorkflowParser.String_literalContext(
1813 self, self._ctx, self.state)
1814 self.enterRule(localctx, 58, self.RULE_string_literal)
1815 try:
1816 self.enterOuterAlt(localctx, 1)
1817 self.state = 242
1818 self.match(SimpleWorkflowParser.STRING)
1819 except RecognitionException as re:
1820 localctx.exception = re
1821 self._errHandler.reportError(self, re)
1822 self._errHandler.recover(self, re)
1823 finally:
1824 self.exitRule()
1825 return localctx
1827 class Integer_numberContext(ParserRuleContext):
1828 __slots__ = 'parser'
1830 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1831 super().__init__(parent, invokingState)
1832 self.parser = parser
1834 def Digits(self):
1835 return self.getToken(SimpleWorkflowParser.Digits, 0)
1837 def Sign(self):
1838 return self.getToken(SimpleWorkflowParser.Sign, 0)
1840 def getRuleIndex(self):
1841 return SimpleWorkflowParser.RULE_integer_number
1843 def enterRule(self, listener: ParseTreeListener):
1844 if hasattr(listener, "enterInteger_number"):
1845 listener.enterInteger_number(self)
1847 def exitRule(self, listener: ParseTreeListener):
1848 if hasattr(listener, "exitInteger_number"):
1849 listener.exitInteger_number(self)
1851 def integer_number(self):
1853 localctx = SimpleWorkflowParser.Integer_numberContext(
1854 self, self._ctx, self.state)
1855 self.enterRule(localctx, 60, self.RULE_integer_number)
1856 self._la = 0 # Token type
1857 try:
1858 self.enterOuterAlt(localctx, 1)
1859 self.state = 245
1860 self._errHandler.sync(self)
1861 _la = self._input.LA(1)
1862 if _la == SimpleWorkflowParser.Sign:
1863 self.state = 244
1864 self.match(SimpleWorkflowParser.Sign)
1866 self.state = 247
1867 self.match(SimpleWorkflowParser.Digits)
1868 except RecognitionException as re:
1869 localctx.exception = re
1870 self._errHandler.reportError(self, re)
1871 self._errHandler.recover(self, re)
1872 finally:
1873 self.exitRule()
1874 return localctx
1876 class Real_numberContext(ParserRuleContext):
1877 __slots__ = 'parser'
1879 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1880 super().__init__(parent, invokingState)
1881 self.parser = parser
1883 def Digits(self, i: int = None):
1884 if i is None:
1885 return self.getTokens(SimpleWorkflowParser.Digits)
1886 else:
1887 return self.getToken(SimpleWorkflowParser.Digits, i)
1889 def Sign(self, i: int = None):
1890 if i is None:
1891 return self.getTokens(SimpleWorkflowParser.Sign)
1892 else:
1893 return self.getToken(SimpleWorkflowParser.Sign, i)
1895 def getRuleIndex(self):
1896 return SimpleWorkflowParser.RULE_real_number
1898 def enterRule(self, listener: ParseTreeListener):
1899 if hasattr(listener, "enterReal_number"):
1900 listener.enterReal_number(self)
1902 def exitRule(self, listener: ParseTreeListener):
1903 if hasattr(listener, "exitReal_number"):
1904 listener.exitReal_number(self)
1906 def real_number(self):
1908 localctx = SimpleWorkflowParser.Real_numberContext(
1909 self, self._ctx, self.state)
1910 self.enterRule(localctx, 62, self.RULE_real_number)
1911 self._la = 0 # Token type
1912 try:
1913 self.state = 271
1914 self._errHandler.sync(self)
1915 la_ = self._interp.adaptivePredict(self._input, 23, self._ctx)
1916 if la_ == 1:
1917 self.enterOuterAlt(localctx, 1)
1918 self.state = 250
1919 self._errHandler.sync(self)
1920 _la = self._input.LA(1)
1921 if _la == SimpleWorkflowParser.Sign:
1922 self.state = 249
1923 self.match(SimpleWorkflowParser.Sign)
1925 self.state = 252
1926 self.match(SimpleWorkflowParser.Digits)
1927 self.state = 253
1928 self.match(SimpleWorkflowParser.T__29)
1929 self.state = 254
1930 self.match(SimpleWorkflowParser.Digits)
1931 self.state = 260
1932 self._errHandler.sync(self)
1933 _la = self._input.LA(1)
1934 if _la == SimpleWorkflowParser.T__32:
1935 self.state = 255
1936 self.match(SimpleWorkflowParser.T__32)
1937 self.state = 257
1938 self._errHandler.sync(self)
1939 _la = self._input.LA(1)
1940 if _la == SimpleWorkflowParser.Sign:
1941 self.state = 256
1942 self.match(SimpleWorkflowParser.Sign)
1944 self.state = 259
1945 self.match(SimpleWorkflowParser.Digits)
1947 pass
1949 elif la_ == 2:
1950 self.enterOuterAlt(localctx, 2)
1951 self.state = 263
1952 self._errHandler.sync(self)
1953 _la = self._input.LA(1)
1954 if _la == SimpleWorkflowParser.Sign:
1955 self.state = 262
1956 self.match(SimpleWorkflowParser.Sign)
1958 self.state = 265
1959 self.match(SimpleWorkflowParser.Digits)
1960 self.state = 266
1961 self.match(SimpleWorkflowParser.T__32)
1962 self.state = 268
1963 self._errHandler.sync(self)
1964 _la = self._input.LA(1)
1965 if _la == SimpleWorkflowParser.Sign:
1966 self.state = 267
1967 self.match(SimpleWorkflowParser.Sign)
1969 self.state = 270
1970 self.match(SimpleWorkflowParser.Digits)
1971 pass
1973 except RecognitionException as re:
1974 localctx.exception = re
1975 self._errHandler.reportError(self, re)
1976 self._errHandler.recover(self, re)
1977 finally:
1978 self.exitRule()
1979 return localctx