# Generated from qasm3Parser.g4 by ANTLR 4.13.2
# 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
[docs]
def serializedATN():
return [
4,
1,
101,
768,
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,
1,
0,
3,
0,
122,
8,
0,
1,
0,
5,
0,
125,
8,
0,
10,
0,
12,
0,
128,
9,
0,
1,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
1,
2,
5,
2,
138,
8,
2,
10,
2,
12,
2,
141,
9,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
1,
2,
3,
2,
170,
8,
2,
3,
2,
172,
8,
2,
1,
3,
1,
3,
3,
3,
176,
8,
3,
1,
4,
1,
4,
5,
4,
180,
8,
4,
10,
4,
12,
4,
183,
9,
4,
1,
4,
1,
4,
1,
5,
1,
5,
1,
5,
1,
6,
1,
6,
3,
6,
192,
8,
6,
1,
7,
1,
7,
1,
7,
1,
7,
1,
8,
1,
8,
1,
8,
1,
8,
1,
9,
1,
9,
1,
9,
1,
10,
1,
10,
1,
10,
1,
11,
1,
11,
1,
11,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
1,
12,
3,
12,
221,
8,
12,
1,
12,
1,
12,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
1,
13,
3,
13,
232,
8,
13,
1,
14,
1,
14,
1,
14,
3,
14,
237,
8,
14,
1,
14,
1,
14,
1,
15,
1,
15,
1,
15,
1,
15,
1,
15,
1,
15,
1,
16,
1,
16,
3,
16,
249,
8,
16,
1,
16,
1,
16,
1,
17,
1,
17,
3,
17,
255,
8,
17,
1,
17,
1,
17,
1,
18,
1,
18,
1,
18,
3,
18,
262,
8,
18,
1,
18,
1,
18,
1,
19,
5,
19,
267,
8,
19,
10,
19,
12,
19,
270,
9,
19,
1,
19,
1,
19,
1,
19,
3,
19,
275,
8,
19,
1,
19,
3,
19,
278,
8,
19,
1,
19,
3,
19,
281,
8,
19,
1,
19,
1,
19,
1,
19,
1,
19,
5,
19,
287,
8,
19,
10,
19,
12,
19,
290,
9,
19,
1,
19,
1,
19,
1,
19,
3,
19,
295,
8,
19,
1,
19,
3,
19,
298,
8,
19,
1,
19,
3,
19,
301,
8,
19,
1,
19,
3,
19,
304,
8,
19,
1,
19,
3,
19,
307,
8,
19,
1,
20,
1,
20,
1,
20,
3,
20,
312,
8,
20,
1,
20,
1,
20,
1,
21,
1,
21,
1,
21,
1,
21,
1,
22,
1,
22,
1,
22,
1,
22,
1,
22,
1,
22,
1,
23,
1,
23,
3,
23,
328,
8,
23,
1,
23,
1,
23,
1,
23,
3,
23,
333,
8,
23,
1,
23,
1,
23,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
25,
1,
25,
1,
25,
3,
25,
347,
8,
25,
1,
25,
1,
25,
1,
25,
1,
26,
1,
26,
1,
26,
3,
26,
355,
8,
26,
1,
26,
1,
26,
1,
27,
1,
27,
1,
27,
1,
27,
1,
28,
1,
28,
1,
28,
1,
28,
3,
28,
367,
8,
28,
1,
28,
1,
28,
3,
28,
371,
8,
28,
1,
28,
1,
28,
1,
29,
1,
29,
1,
29,
1,
29,
3,
29,
379,
8,
29,
1,
29,
1,
29,
3,
29,
383,
8,
29,
1,
29,
1,
29,
1,
30,
1,
30,
1,
30,
1,
30,
3,
30,
391,
8,
30,
1,
30,
3,
30,
394,
8,
30,
1,
30,
1,
30,
1,
30,
1,
31,
1,
31,
1,
31,
1,
31,
3,
31,
403,
8,
31,
1,
31,
1,
31,
1,
32,
1,
32,
1,
32,
1,
33,
1,
33,
1,
33,
1,
33,
3,
33,
414,
8,
33,
1,
33,
3,
33,
417,
8,
33,
1,
33,
1,
33,
3,
33,
421,
8,
33,
1,
33,
1,
33,
5,
33,
425,
8,
33,
10,
33,
12,
33,
428,
9,
33,
1,
33,
1,
33,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
3,
34,
441,
8,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
3,
34,
455,
8,
34,
1,
34,
1,
34,
3,
34,
459,
8,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
1,
34,
5,
34,
496,
8,
34,
10,
34,
12,
34,
499,
9,
34,
1,
35,
1,
35,
1,
35,
5,
35,
504,
8,
35,
10,
35,
12,
35,
507,
9,
35,
1,
36,
1,
36,
1,
36,
3,
36,
512,
8,
36,
1,
37,
1,
37,
1,
37,
1,
38,
3,
38,
518,
8,
38,
1,
38,
1,
38,
3,
38,
522,
8,
38,
1,
38,
1,
38,
3,
38,
526,
8,
38,
1,
39,
1,
39,
1,
39,
1,
39,
5,
39,
532,
8,
39,
10,
39,
12,
39,
535,
9,
39,
1,
39,
3,
39,
538,
8,
39,
1,
39,
1,
39,
1,
40,
1,
40,
1,
40,
3,
40,
545,
8,
40,
1,
40,
1,
40,
1,
40,
3,
40,
550,
8,
40,
5,
40,
552,
8,
40,
10,
40,
12,
40,
555,
9,
40,
1,
40,
3,
40,
558,
8,
40,
1,
40,
1,
40,
1,
41,
1,
41,
1,
41,
1,
41,
3,
41,
566,
8,
41,
1,
41,
1,
41,
1,
41,
3,
41,
571,
8,
41,
5,
41,
573,
8,
41,
10,
41,
12,
41,
576,
9,
41,
1,
41,
3,
41,
579,
8,
41,
3,
41,
581,
8,
41,
1,
41,
1,
41,
1,
42,
1,
42,
5,
42,
587,
8,
42,
10,
42,
12,
42,
590,
9,
42,
1,
43,
1,
43,
1,
43,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
1,
44,
3,
44,
606,
8,
44,
3,
44,
608,
8,
44,
1,
44,
1,
44,
1,
45,
1,
45,
3,
45,
614,
8,
45,
1,
45,
1,
45,
3,
45,
618,
8,
45,
1,
45,
1,
45,
3,
45,
622,
8,
45,
1,
45,
1,
45,
3,
45,
626,
8,
45,
1,
45,
1,
45,
3,
45,
630,
8,
45,
1,
45,
1,
45,
1,
45,
1,
45,
1,
45,
1,
45,
1,
45,
1,
45,
3,
45,
640,
8,
45,
3,
45,
642,
8,
45,
1,
46,
1,
46,
3,
46,
646,
8,
46,
1,
47,
1,
47,
1,
47,
1,
47,
1,
47,
1,
47,
1,
47,
1,
48,
1,
48,
1,
48,
1,
48,
1,
48,
1,
48,
1,
48,
1,
48,
1,
48,
3,
48,
664,
8,
48,
1,
48,
1,
48,
1,
49,
1,
49,
1,
49,
1,
49,
1,
50,
1,
50,
3,
50,
674,
8,
50,
1,
51,
1,
51,
1,
51,
1,
51,
3,
51,
680,
8,
51,
3,
51,
682,
8,
51,
1,
52,
1,
52,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
1,
53,
3,
53,
695,
8,
53,
1,
53,
1,
53,
1,
53,
3,
53,
700,
8,
53,
1,
54,
1,
54,
1,
54,
5,
54,
705,
8,
54,
10,
54,
12,
54,
708,
9,
54,
1,
54,
3,
54,
711,
8,
54,
1,
55,
1,
55,
1,
55,
5,
55,
716,
8,
55,
10,
55,
12,
55,
719,
9,
55,
1,
55,
3,
55,
722,
8,
55,
1,
56,
1,
56,
1,
56,
5,
56,
727,
8,
56,
10,
56,
12,
56,
730,
9,
56,
1,
56,
3,
56,
733,
8,
56,
1,
57,
1,
57,
1,
57,
5,
57,
738,
8,
57,
10,
57,
12,
57,
741,
9,
57,
1,
57,
3,
57,
744,
8,
57,
1,
58,
1,
58,
1,
58,
5,
58,
749,
8,
58,
10,
58,
12,
58,
752,
9,
58,
1,
58,
3,
58,
755,
8,
58,
1,
59,
1,
59,
1,
59,
5,
59,
760,
8,
59,
10,
59,
12,
59,
763,
9,
59,
1,
59,
3,
59,
766,
8,
59,
1,
59,
1,
426,
1,
68,
60,
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,
0,
10,
1,
0,
21,
22,
2,
0,
25,
25,
27,
27,
2,
0,
60,
60,
78,
78,
2,
0,
64,
64,
75,
76,
2,
0,
49,
49,
82,
91,
2,
0,
65,
65,
67,
68,
2,
0,
62,
62,
64,
64,
1,
0,
41,
42,
1,
0,
23,
24,
1,
0,
87,
88,
850,
0,
121,
1,
0,
0,
0,
2,
131,
1,
0,
0,
0,
4,
171,
1,
0,
0,
0,
6,
173,
1,
0,
0,
0,
8,
177,
1,
0,
0,
0,
10,
186,
1,
0,
0,
0,
12,
191,
1,
0,
0,
0,
14,
193,
1,
0,
0,
0,
16,
197,
1,
0,
0,
0,
18,
201,
1,
0,
0,
0,
20,
204,
1,
0,
0,
0,
22,
207,
1,
0,
0,
0,
24,
210,
1,
0,
0,
0,
26,
224,
1,
0,
0,
0,
28,
233,
1,
0,
0,
0,
30,
240,
1,
0,
0,
0,
32,
246,
1,
0,
0,
0,
34,
252,
1,
0,
0,
0,
36,
258,
1,
0,
0,
0,
38,
306,
1,
0,
0,
0,
40,
308,
1,
0,
0,
0,
42,
315,
1,
0,
0,
0,
44,
319,
1,
0,
0,
0,
46,
327,
1,
0,
0,
0,
48,
336,
1,
0,
0,
0,
50,
343,
1,
0,
0,
0,
52,
351,
1,
0,
0,
0,
54,
358,
1,
0,
0,
0,
56,
362,
1,
0,
0,
0,
58,
374,
1,
0,
0,
0,
60,
386,
1,
0,
0,
0,
62,
398,
1,
0,
0,
0,
64,
406,
1,
0,
0,
0,
66,
409,
1,
0,
0,
0,
68,
458,
1,
0,
0,
0,
70,
500,
1,
0,
0,
0,
72,
511,
1,
0,
0,
0,
74,
513,
1,
0,
0,
0,
76,
517,
1,
0,
0,
0,
78,
527,
1,
0,
0,
0,
80,
541,
1,
0,
0,
0,
82,
561,
1,
0,
0,
0,
84,
584,
1,
0,
0,
0,
86,
591,
1,
0,
0,
0,
88,
607,
1,
0,
0,
0,
90,
641,
1,
0,
0,
0,
92,
643,
1,
0,
0,
0,
94,
647,
1,
0,
0,
0,
96,
654,
1,
0,
0,
0,
98,
667,
1,
0,
0,
0,
100,
673,
1,
0,
0,
0,
102,
681,
1,
0,
0,
0,
104,
683,
1,
0,
0,
0,
106,
699,
1,
0,
0,
0,
108,
701,
1,
0,
0,
0,
110,
712,
1,
0,
0,
0,
112,
723,
1,
0,
0,
0,
114,
734,
1,
0,
0,
0,
116,
745,
1,
0,
0,
0,
118,
756,
1,
0,
0,
0,
120,
122,
3,
2,
1,
0,
121,
120,
1,
0,
0,
0,
121,
122,
1,
0,
0,
0,
122,
126,
1,
0,
0,
0,
123,
125,
3,
4,
2,
0,
124,
123,
1,
0,
0,
0,
125,
128,
1,
0,
0,
0,
126,
124,
1,
0,
0,
0,
126,
127,
1,
0,
0,
0,
127,
129,
1,
0,
0,
0,
128,
126,
1,
0,
0,
0,
129,
130,
5,
0,
0,
1,
130,
1,
1,
0,
0,
0,
131,
132,
5,
1,
0,
0,
132,
133,
5,
98,
0,
0,
133,
134,
5,
57,
0,
0,
134,
3,
1,
0,
0,
0,
135,
172,
3,
10,
5,
0,
136,
138,
3,
6,
3,
0,
137,
136,
1,
0,
0,
0,
138,
141,
1,
0,
0,
0,
139,
137,
1,
0,
0,
0,
139,
140,
1,
0,
0,
0,
140,
169,
1,
0,
0,
0,
141,
139,
1,
0,
0,
0,
142,
170,
3,
44,
22,
0,
143,
170,
3,
62,
31,
0,
144,
170,
3,
32,
16,
0,
145,
170,
3,
34,
17,
0,
146,
170,
3,
18,
9,
0,
147,
170,
3,
14,
7,
0,
148,
170,
3,
46,
23,
0,
149,
170,
3,
48,
24,
0,
150,
170,
3,
20,
10,
0,
151,
170,
3,
56,
28,
0,
152,
170,
3,
66,
33,
0,
153,
170,
3,
36,
18,
0,
154,
170,
3,
22,
11,
0,
155,
170,
3,
64,
32,
0,
156,
170,
3,
58,
29,
0,
157,
170,
3,
24,
12,
0,
158,
170,
3,
38,
19,
0,
159,
170,
3,
60,
30,
0,
160,
170,
3,
26,
13,
0,
161,
170,
3,
16,
8,
0,
162,
170,
3,
50,
25,
0,
163,
170,
3,
40,
20,
0,
164,
170,
3,
52,
26,
0,
165,
170,
3,
54,
27,
0,
166,
170,
3,
42,
21,
0,
167,
170,
3,
28,
14,
0,
168,
170,
3,
30,
15,
0,
169,
142,
1,
0,
0,
0,
169,
143,
1,
0,
0,
0,
169,
144,
1,
0,
0,
0,
169,
145,
1,
0,
0,
0,
169,
146,
1,
0,
0,
0,
169,
147,
1,
0,
0,
0,
169,
148,
1,
0,
0,
0,
169,
149,
1,
0,
0,
0,
169,
150,
1,
0,
0,
0,
169,
151,
1,
0,
0,
0,
169,
152,
1,
0,
0,
0,
169,
153,
1,
0,
0,
0,
169,
154,
1,
0,
0,
0,
169,
155,
1,
0,
0,
0,
169,
156,
1,
0,
0,
0,
169,
157,
1,
0,
0,
0,
169,
158,
1,
0,
0,
0,
169,
159,
1,
0,
0,
0,
169,
160,
1,
0,
0,
0,
169,
161,
1,
0,
0,
0,
169,
162,
1,
0,
0,
0,
169,
163,
1,
0,
0,
0,
169,
164,
1,
0,
0,
0,
169,
165,
1,
0,
0,
0,
169,
166,
1,
0,
0,
0,
169,
167,
1,
0,
0,
0,
169,
168,
1,
0,
0,
0,
170,
172,
1,
0,
0,
0,
171,
135,
1,
0,
0,
0,
171,
139,
1,
0,
0,
0,
172,
5,
1,
0,
0,
0,
173,
175,
5,
20,
0,
0,
174,
176,
5,
101,
0,
0,
175,
174,
1,
0,
0,
0,
175,
176,
1,
0,
0,
0,
176,
7,
1,
0,
0,
0,
177,
181,
5,
52,
0,
0,
178,
180,
3,
4,
2,
0,
179,
178,
1,
0,
0,
0,
180,
183,
1,
0,
0,
0,
181,
179,
1,
0,
0,
0,
181,
182,
1,
0,
0,
0,
182,
184,
1,
0,
0,
0,
183,
181,
1,
0,
0,
0,
184,
185,
5,
53,
0,
0,
185,
9,
1,
0,
0,
0,
186,
187,
5,
19,
0,
0,
187,
188,
5,
101,
0,
0,
188,
11,
1,
0,
0,
0,
189,
192,
3,
4,
2,
0,
190,
192,
3,
8,
4,
0,
191,
189,
1,
0,
0,
0,
191,
190,
1,
0,
0,
0,
192,
13,
1,
0,
0,
0,
193,
194,
5,
3,
0,
0,
194,
195,
5,
92,
0,
0,
195,
196,
5,
57,
0,
0,
196,
15,
1,
0,
0,
0,
197,
198,
5,
2,
0,
0,
198,
199,
5,
92,
0,
0,
199,
200,
5,
57,
0,
0,
200,
17,
1,
0,
0,
0,
201,
202,
5,
10,
0,
0,
202,
203,
5,
57,
0,
0,
203,
19,
1,
0,
0,
0,
204,
205,
5,
11,
0,
0,
205,
206,
5,
57,
0,
0,
206,
21,
1,
0,
0,
0,
207,
208,
5,
14,
0,
0,
208,
209,
5,
57,
0,
0,
209,
23,
1,
0,
0,
0,
210,
211,
5,
16,
0,
0,
211,
212,
3,
90,
45,
0,
212,
213,
5,
87,
0,
0,
213,
220,
5,
18,
0,
0,
214,
221,
3,
78,
39,
0,
215,
216,
5,
50,
0,
0,
216,
217,
3,
76,
38,
0,
217,
218,
5,
51,
0,
0,
218,
221,
1,
0,
0,
0,
219,
221,
5,
87,
0,
0,
220,
214,
1,
0,
0,
0,
220,
215,
1,
0,
0,
0,
220,
219,
1,
0,
0,
0,
221,
222,
1,
0,
0,
0,
222,
223,
3,
12,
6,
0,
223,
25,
1,
0,
0,
0,
224,
225,
5,
12,
0,
0,
225,
226,
5,
54,
0,
0,
226,
227,
3,
68,
34,
0,
227,
228,
5,
55,
0,
0,
228,
231,
3,
12,
6,
0,
229,
230,
5,
13,
0,
0,
230,
232,
3,
12,
6,
0,
231,
229,
1,
0,
0,
0,
231,
232,
1,
0,
0,
0,
232,
27,
1,
0,
0,
0,
233,
236,
5,
15,
0,
0,
234,
237,
3,
68,
34,
0,
235,
237,
3,
74,
37,
0,
236,
234,
1,
0,
0,
0,
236,
235,
1,
0,
0,
0,
236,
237,
1,
0,
0,
0,
237,
238,
1,
0,
0,
0,
238,
239,
5,
57,
0,
0,
239,
29,
1,
0,
0,
0,
240,
241,
5,
17,
0,
0,
241,
242,
5,
54,
0,
0,
242,
243,
3,
68,
34,
0,
243,
244,
5,
55,
0,
0,
244,
245,
3,
12,
6,
0,
245,
31,
1,
0,
0,
0,
246,
248,
5,
48,
0,
0,
247,
249,
3,
116,
58,
0,
248,
247,
1,
0,
0,
0,
248,
249,
1,
0,
0,
0,
249,
250,
1,
0,
0,
0,
250,
251,
5,
57,
0,
0,
251,
33,
1,
0,
0,
0,
252,
254,
5,
8,
0,
0,
253,
255,
3,
98,
49,
0,
254,
253,
1,
0,
0,
0,
254,
255,
1,
0,
0,
0,
255,
256,
1,
0,
0,
0,
256,
257,
3,
8,
4,
0,
257,
35,
1,
0,
0,
0,
258,
259,
5,
45,
0,
0,
259,
261,
3,
98,
49,
0,
260,
262,
3,
116,
58,
0,
261,
260,
1,
0,
0,
0,
261,
262,
1,
0,
0,
0,
262,
263,
1,
0,
0,
0,
263,
264,
5,
57,
0,
0,
264,
37,
1,
0,
0,
0,
265,
267,
3,
88,
44,
0,
266,
265,
1,
0,
0,
0,
267,
270,
1,
0,
0,
0,
268,
266,
1,
0,
0,
0,
268,
269,
1,
0,
0,
0,
269,
271,
1,
0,
0,
0,
270,
268,
1,
0,
0,
0,
271,
277,
5,
87,
0,
0,
272,
274,
5,
54,
0,
0,
273,
275,
3,
110,
55,
0,
274,
273,
1,
0,
0,
0,
274,
275,
1,
0,
0,
0,
275,
276,
1,
0,
0,
0,
276,
278,
5,
55,
0,
0,
277,
272,
1,
0,
0,
0,
277,
278,
1,
0,
0,
0,
278,
280,
1,
0,
0,
0,
279,
281,
3,
98,
49,
0,
280,
279,
1,
0,
0,
0,
280,
281,
1,
0,
0,
0,
281,
282,
1,
0,
0,
0,
282,
283,
3,
116,
58,
0,
283,
284,
5,
57,
0,
0,
284,
307,
1,
0,
0,
0,
285,
287,
3,
88,
44,
0,
286,
285,
1,
0,
0,
0,
287,
290,
1,
0,
0,
0,
288,
286,
1,
0,
0,
0,
288,
289,
1,
0,
0,
0,
289,
291,
1,
0,
0,
0,
290,
288,
1,
0,
0,
0,
291,
297,
5,
38,
0,
0,
292,
294,
5,
54,
0,
0,
293,
295,
3,
110,
55,
0,
294,
293,
1,
0,
0,
0,
294,
295,
1,
0,
0,
0,
295,
296,
1,
0,
0,
0,
296,
298,
5,
55,
0,
0,
297,
292,
1,
0,
0,
0,
297,
298,
1,
0,
0,
0,
298,
300,
1,
0,
0,
0,
299,
301,
3,
98,
49,
0,
300,
299,
1,
0,
0,
0,
300,
301,
1,
0,
0,
0,
301,
303,
1,
0,
0,
0,
302,
304,
3,
116,
58,
0,
303,
302,
1,
0,
0,
0,
303,
304,
1,
0,
0,
0,
304,
305,
1,
0,
0,
0,
305,
307,
5,
57,
0,
0,
306,
268,
1,
0,
0,
0,
306,
288,
1,
0,
0,
0,
307,
39,
1,
0,
0,
0,
308,
311,
3,
74,
37,
0,
309,
310,
5,
61,
0,
0,
310,
312,
3,
84,
42,
0,
311,
309,
1,
0,
0,
0,
311,
312,
1,
0,
0,
0,
312,
313,
1,
0,
0,
0,
313,
314,
5,
57,
0,
0,
314,
41,
1,
0,
0,
0,
315,
316,
5,
46,
0,
0,
316,
317,
3,
100,
50,
0,
317,
318,
5,
57,
0,
0,
318,
43,
1,
0,
0,
0,
319,
320,
5,
9,
0,
0,
320,
321,
5,
87,
0,
0,
321,
322,
5,
60,
0,
0,
322,
323,
3,
70,
35,
0,
323,
324,
5,
57,
0,
0,
324,
45,
1,
0,
0,
0,
325,
328,
3,
90,
45,
0,
326,
328,
3,
94,
47,
0,
327,
325,
1,
0,
0,
0,
327,
326,
1,
0,
0,
0,
328,
329,
1,
0,
0,
0,
329,
332,
5,
87,
0,
0,
330,
331,
5,
60,
0,
0,
331,
333,
3,
72,
36,
0,
332,
330,
1,
0,
0,
0,
332,
333,
1,
0,
0,
0,
333,
334,
1,
0,
0,
0,
334,
335,
5,
57,
0,
0,
335,
47,
1,
0,
0,
0,
336,
337,
5,
23,
0,
0,
337,
338,
3,
90,
45,
0,
338,
339,
5,
87,
0,
0,
339,
340,
5,
60,
0,
0,
340,
341,
3,
72,
36,
0,
341,
342,
5,
57,
0,
0,
342,
49,
1,
0,
0,
0,
343,
346,
7,
0,
0,
0,
344,
347,
3,
90,
45,
0,
345,
347,
3,
94,
47,
0,
346,
344,
1,
0,
0,
0,
346,
345,
1,
0,
0,
0,
347,
348,
1,
0,
0,
0,
348,
349,
5,
87,
0,
0,
349,
350,
5,
57,
0,
0,
350,
51,
1,
0,
0,
0,
351,
352,
7,
1,
0,
0,
352,
354,
5,
87,
0,
0,
353,
355,
3,
98,
49,
0,
354,
353,
1,
0,
0,
0,
354,
355,
1,
0,
0,
0,
355,
356,
1,
0,
0,
0,
356,
357,
5,
57,
0,
0,
357,
53,
1,
0,
0,
0,
358,
359,
3,
92,
46,
0,
359,
360,
5,
87,
0,
0,
360,
361,
5,
57,
0,
0,
361,
55,
1,
0,
0,
0,
362,
363,
5,
4,
0,
0,
363,
364,
5,
87,
0,
0,
364,
366,
5,
54,
0,
0,
365,
367,
3,
108,
54,
0,
366,
365,
1,
0,
0,
0,
366,
367,
1,
0,
0,
0,
367,
368,
1,
0,
0,
0,
368,
370,
5,
55,
0,
0,
369,
371,
3,
86,
43,
0,
370,
369,
1,
0,
0,
0,
370,
371,
1,
0,
0,
0,
371,
372,
1,
0,
0,
0,
372,
373,
3,
8,
4,
0,
373,
57,
1,
0,
0,
0,
374,
375,
5,
7,
0,
0,
375,
376,
5,
87,
0,
0,
376,
378,
5,
54,
0,
0,
377,
379,
3,
118,
59,
0,
378,
377,
1,
0,
0,
0,
378,
379,
1,
0,
0,
0,
379,
380,
1,
0,
0,
0,
380,
382,
5,
55,
0,
0,
381,
383,
3,
86,
43,
0,
382,
381,
1,
0,
0,
0,
382,
383,
1,
0,
0,
0,
383,
384,
1,
0,
0,
0,
384,
385,
5,
57,
0,
0,
385,
59,
1,
0,
0,
0,
386,
387,
5,
6,
0,
0,
387,
393,
5,
87,
0,
0,
388,
390,
5,
54,
0,
0,
389,
391,
3,
114,
57,
0,
390,
389,
1,
0,
0,
0,
390,
391,
1,
0,
0,
0,
391,
392,
1,
0,
0,
0,
392,
394,
5,
55,
0,
0,
393,
388,
1,
0,
0,
0,
393,
394,
1,
0,
0,
0,
394,
395,
1,
0,
0,
0,
395,
396,
3,
114,
57,
0,
396,
397,
3,
8,
4,
0,
397,
61,
1,
0,
0,
0,
398,
399,
3,
84,
42,
0,
399,
402,
7,
2,
0,
0,
400,
403,
3,
68,
34,
0,
401,
403,
3,
74,
37,
0,
402,
400,
1,
0,
0,
0,
402,
401,
1,
0,
0,
0,
403,
404,
1,
0,
0,
0,
404,
405,
5,
57,
0,
0,
405,
63,
1,
0,
0,
0,
406,
407,
3,
68,
34,
0,
407,
408,
5,
57,
0,
0,
408,
65,
1,
0,
0,
0,
409,
410,
5,
5,
0,
0,
410,
416,
5,
87,
0,
0,
411,
413,
5,
54,
0,
0,
412,
414,
3,
108,
54,
0,
413,
412,
1,
0,
0,
0,
413,
414,
1,
0,
0,
0,
414,
415,
1,
0,
0,
0,
415,
417,
5,
55,
0,
0,
416,
411,
1,
0,
0,
0,
416,
417,
1,
0,
0,
0,
417,
418,
1,
0,
0,
0,
418,
420,
3,
112,
56,
0,
419,
421,
3,
86,
43,
0,
420,
419,
1,
0,
0,
0,
420,
421,
1,
0,
0,
0,
421,
422,
1,
0,
0,
0,
422,
426,
5,
52,
0,
0,
423,
425,
9,
0,
0,
0,
424,
423,
1,
0,
0,
0,
425,
428,
1,
0,
0,
0,
426,
427,
1,
0,
0,
0,
426,
424,
1,
0,
0,
0,
427,
429,
1,
0,
0,
0,
428,
426,
1,
0,
0,
0,
429,
430,
5,
53,
0,
0,
430,
67,
1,
0,
0,
0,
431,
432,
6,
34,
-1,
0,
432,
433,
5,
54,
0,
0,
433,
434,
3,
68,
34,
0,
434,
435,
5,
55,
0,
0,
435,
459,
1,
0,
0,
0,
436,
437,
7,
3,
0,
0,
437,
459,
3,
68,
34,
15,
438,
441,
3,
90,
45,
0,
439,
441,
3,
94,
47,
0,
440,
438,
1,
0,
0,
0,
440,
439,
1,
0,
0,
0,
441,
442,
1,
0,
0,
0,
442,
443,
5,
54,
0,
0,
443,
444,
3,
68,
34,
0,
444,
445,
5,
55,
0,
0,
445,
459,
1,
0,
0,
0,
446,
447,
5,
44,
0,
0,
447,
448,
5,
54,
0,
0,
448,
449,
3,
8,
4,
0,
449,
450,
5,
55,
0,
0,
450,
459,
1,
0,
0,
0,
451,
452,
5,
87,
0,
0,
452,
454,
5,
54,
0,
0,
453,
455,
3,
110,
55,
0,
454,
453,
1,
0,
0,
0,
454,
455,
1,
0,
0,
0,
455,
456,
1,
0,
0,
0,
456,
459,
5,
55,
0,
0,
457,
459,
7,
4,
0,
0,
458,
431,
1,
0,
0,
0,
458,
436,
1,
0,
0,
0,
458,
440,
1,
0,
0,
0,
458,
446,
1,
0,
0,
0,
458,
451,
1,
0,
0,
0,
458,
457,
1,
0,
0,
0,
459,
497,
1,
0,
0,
0,
460,
461,
10,
16,
0,
0,
461,
462,
5,
66,
0,
0,
462,
496,
3,
68,
34,
16,
463,
464,
10,
14,
0,
0,
464,
465,
7,
5,
0,
0,
465,
496,
3,
68,
34,
15,
466,
467,
10,
13,
0,
0,
467,
468,
7,
6,
0,
0,
468,
496,
3,
68,
34,
14,
469,
470,
10,
12,
0,
0,
470,
471,
5,
80,
0,
0,
471,
496,
3,
68,
34,
13,
472,
473,
10,
11,
0,
0,
473,
474,
5,
79,
0,
0,
474,
496,
3,
68,
34,
12,
475,
476,
10,
10,
0,
0,
476,
477,
5,
77,
0,
0,
477,
496,
3,
68,
34,
11,
478,
479,
10,
9,
0,
0,
479,
480,
5,
71,
0,
0,
480,
496,
3,
68,
34,
10,
481,
482,
10,
8,
0,
0,
482,
483,
5,
73,
0,
0,
483,
496,
3,
68,
34,
9,
484,
485,
10,
7,
0,
0,
485,
486,
5,
69,
0,
0,
486,
496,
3,
68,
34,
8,
487,
488,
10,
6,
0,
0,
488,
489,
5,
72,
0,
0,
489,
496,
3,
68,
34,
7,
490,
491,
10,
5,
0,
0,
491,
492,
5,
70,
0,
0,
492,
496,
3,
68,
34,
6,
493,
494,
10,
17,
0,
0,
494,
496,
3,
82,
41,
0,
495,
460,
1,
0,
0,
0,
495,
463,
1,
0,
0,
0,
495,
466,
1,
0,
0,
0,
495,
469,
1,
0,
0,
0,
495,
472,
1,
0,
0,
0,
495,
475,
1,
0,
0,
0,
495,
478,
1,
0,
0,
0,
495,
481,
1,
0,
0,
0,
495,
484,
1,
0,
0,
0,
495,
487,
1,
0,
0,
0,
495,
490,
1,
0,
0,
0,
495,
493,
1,
0,
0,
0,
496,
499,
1,
0,
0,
0,
497,
495,
1,
0,
0,
0,
497,
498,
1,
0,
0,
0,
498,
69,
1,
0,
0,
0,
499,
497,
1,
0,
0,
0,
500,
505,
3,
68,
34,
0,
501,
502,
5,
63,
0,
0,
502,
504,
3,
68,
34,
0,
503,
501,
1,
0,
0,
0,
504,
507,
1,
0,
0,
0,
505,
503,
1,
0,
0,
0,
505,
506,
1,
0,
0,
0,
506,
71,
1,
0,
0,
0,
507,
505,
1,
0,
0,
0,
508,
512,
3,
80,
40,
0,
509,
512,
3,
68,
34,
0,
510,
512,
3,
74,
37,
0,
511,
508,
1,
0,
0,
0,
511,
509,
1,
0,
0,
0,
511,
510,
1,
0,
0,
0,
512,
73,
1,
0,
0,
0,
513,
514,
5,
47,
0,
0,
514,
515,
3,
100,
50,
0,
515,
75,
1,
0,
0,
0,
516,
518,
3,
68,
34,
0,
517,
516,
1,
0,
0,
0,
517,
518,
1,
0,
0,
0,
518,
519,
1,
0,
0,
0,
519,
521,
5,
56,
0,
0,
520,
522,
3,
68,
34,
0,
521,
520,
1,
0,
0,
0,
521,
522,
1,
0,
0,
0,
522,
525,
1,
0,
0,
0,
523,
524,
5,
56,
0,
0,
524,
526,
3,
68,
34,
0,
525,
523,
1,
0,
0,
0,
525,
526,
1,
0,
0,
0,
526,
77,
1,
0,
0,
0,
527,
528,
5,
52,
0,
0,
528,
533,
3,
68,
34,
0,
529,
530,
5,
59,
0,
0,
530,
532,
3,
68,
34,
0,
531,
529,
1,
0,
0,
0,
532,
535,
1,
0,
0,
0,
533,
531,
1,
0,
0,
0,
533,
534,
1,
0,
0,
0,
534,
537,
1,
0,
0,
0,
535,
533,
1,
0,
0,
0,
536,
538,
5,
59,
0,
0,
537,
536,
1,
0,
0,
0,
537,
538,
1,
0,
0,
0,
538,
539,
1,
0,
0,
0,
539,
540,
5,
53,
0,
0,
540,
79,
1,
0,
0,
0,
541,
544,
5,
52,
0,
0,
542,
545,
3,
68,
34,
0,
543,
545,
3,
80,
40,
0,
544,
542,
1,
0,
0,
0,
544,
543,
1,
0,
0,
0,
545,
553,
1,
0,
0,
0,
546,
549,
5,
59,
0,
0,
547,
550,
3,
68,
34,
0,
548,
550,
3,
80,
40,
0,
549,
547,
1,
0,
0,
0,
549,
548,
1,
0,
0,
0,
550,
552,
1,
0,
0,
0,
551,
546,
1,
0,
0,
0,
552,
555,
1,
0,
0,
0,
553,
551,
1,
0,
0,
0,
553,
554,
1,
0,
0,
0,
554,
557,
1,
0,
0,
0,
555,
553,
1,
0,
0,
0,
556,
558,
5,
59,
0,
0,
557,
556,
1,
0,
0,
0,
557,
558,
1,
0,
0,
0,
558,
559,
1,
0,
0,
0,
559,
560,
5,
53,
0,
0,
560,
81,
1,
0,
0,
0,
561,
580,
5,
50,
0,
0,
562,
581,
3,
78,
39,
0,
563,
566,
3,
68,
34,
0,
564,
566,
3,
76,
38,
0,
565,
563,
1,
0,
0,
0,
565,
564,
1,
0,
0,
0,
566,
574,
1,
0,
0,
0,
567,
570,
5,
59,
0,
0,
568,
571,
3,
68,
34,
0,
569,
571,
3,
76,
38,
0,
570,
568,
1,
0,
0,
0,
570,
569,
1,
0,
0,
0,
571,
573,
1,
0,
0,
0,
572,
567,
1,
0,
0,
0,
573,
576,
1,
0,
0,
0,
574,
572,
1,
0,
0,
0,
574,
575,
1,
0,
0,
0,
575,
578,
1,
0,
0,
0,
576,
574,
1,
0,
0,
0,
577,
579,
5,
59,
0,
0,
578,
577,
1,
0,
0,
0,
578,
579,
1,
0,
0,
0,
579,
581,
1,
0,
0,
0,
580,
562,
1,
0,
0,
0,
580,
565,
1,
0,
0,
0,
581,
582,
1,
0,
0,
0,
582,
583,
5,
51,
0,
0,
583,
83,
1,
0,
0,
0,
584,
588,
5,
87,
0,
0,
585,
587,
3,
82,
41,
0,
586,
585,
1,
0,
0,
0,
587,
590,
1,
0,
0,
0,
588,
586,
1,
0,
0,
0,
588,
589,
1,
0,
0,
0,
589,
85,
1,
0,
0,
0,
590,
588,
1,
0,
0,
0,
591,
592,
5,
61,
0,
0,
592,
593,
3,
90,
45,
0,
593,
87,
1,
0,
0,
0,
594,
608,
5,
39,
0,
0,
595,
596,
5,
40,
0,
0,
596,
597,
5,
54,
0,
0,
597,
598,
3,
68,
34,
0,
598,
599,
5,
55,
0,
0,
599,
608,
1,
0,
0,
0,
600,
605,
7,
7,
0,
0,
601,
602,
5,
54,
0,
0,
602,
603,
3,
68,
34,
0,
603,
604,
5,
55,
0,
0,
604,
606,
1,
0,
0,
0,
605,
601,
1,
0,
0,
0,
605,
606,
1,
0,
0,
0,
606,
608,
1,
0,
0,
0,
607,
594,
1,
0,
0,
0,
607,
595,
1,
0,
0,
0,
607,
600,
1,
0,
0,
0,
608,
609,
1,
0,
0,
0,
609,
610,
5,
74,
0,
0,
610,
89,
1,
0,
0,
0,
611,
613,
5,
29,
0,
0,
612,
614,
3,
98,
49,
0,
613,
612,
1,
0,
0,
0,
613,
614,
1,
0,
0,
0,
614,
642,
1,
0,
0,
0,
615,
617,
5,
30,
0,
0,
616,
618,
3,
98,
49,
0,
617,
616,
1,
0,
0,
0,
617,
618,
1,
0,
0,
0,
618,
642,
1,
0,
0,
0,
619,
621,
5,
31,
0,
0,
620,
622,
3,
98,
49,
0,
621,
620,
1,
0,
0,
0,
621,
622,
1,
0,
0,
0,
622,
642,
1,
0,
0,
0,
623,
625,
5,
32,
0,
0,
624,
626,
3,
98,
49,
0,
625,
624,
1,
0,
0,
0,
625,
626,
1,
0,
0,
0,
626,
642,
1,
0,
0,
0,
627,
629,
5,
33,
0,
0,
628,
630,
3,
98,
49,
0,
629,
628,
1,
0,
0,
0,
629,
630,
1,
0,
0,
0,
630,
642,
1,
0,
0,
0,
631,
642,
5,
28,
0,
0,
632,
642,
5,
36,
0,
0,
633,
642,
5,
37,
0,
0,
634,
639,
5,
34,
0,
0,
635,
636,
5,
50,
0,
0,
636,
637,
3,
90,
45,
0,
637,
638,
5,
51,
0,
0,
638,
640,
1,
0,
0,
0,
639,
635,
1,
0,
0,
0,
639,
640,
1,
0,
0,
0,
640,
642,
1,
0,
0,
0,
641,
611,
1,
0,
0,
0,
641,
615,
1,
0,
0,
0,
641,
619,
1,
0,
0,
0,
641,
623,
1,
0,
0,
0,
641,
627,
1,
0,
0,
0,
641,
631,
1,
0,
0,
0,
641,
632,
1,
0,
0,
0,
641,
633,
1,
0,
0,
0,
641,
634,
1,
0,
0,
0,
642,
91,
1,
0,
0,
0,
643,
645,
5,
26,
0,
0,
644,
646,
3,
98,
49,
0,
645,
644,
1,
0,
0,
0,
645,
646,
1,
0,
0,
0,
646,
93,
1,
0,
0,
0,
647,
648,
5,
35,
0,
0,
648,
649,
5,
50,
0,
0,
649,
650,
3,
90,
45,
0,
650,
651,
5,
59,
0,
0,
651,
652,
3,
110,
55,
0,
652,
653,
5,
51,
0,
0,
653,
95,
1,
0,
0,
0,
654,
655,
7,
8,
0,
0,
655,
656,
5,
35,
0,
0,
656,
657,
5,
50,
0,
0,
657,
658,
3,
90,
45,
0,
658,
663,
5,
59,
0,
0,
659,
664,
3,
110,
55,
0,
660,
661,
5,
43,
0,
0,
661,
662,
5,
60,
0,
0,
662,
664,
3,
68,
34,
0,
663,
659,
1,
0,
0,
0,
663,
660,
1,
0,
0,
0,
664,
665,
1,
0,
0,
0,
665,
666,
5,
51,
0,
0,
666,
97,
1,
0,
0,
0,
667,
668,
5,
50,
0,
0,
668,
669,
3,
68,
34,
0,
669,
670,
5,
51,
0,
0,
670,
99,
1,
0,
0,
0,
671,
674,
3,
84,
42,
0,
672,
674,
5,
88,
0,
0,
673,
671,
1,
0,
0,
0,
673,
672,
1,
0,
0,
0,
674,
101,
1,
0,
0,
0,
675,
682,
3,
90,
45,
0,
676,
682,
3,
96,
48,
0,
677,
679,
5,
27,
0,
0,
678,
680,
3,
98,
49,
0,
679,
678,
1,
0,
0,
0,
679,
680,
1,
0,
0,
0,
680,
682,
1,
0,
0,
0,
681,
675,
1,
0,
0,
0,
681,
676,
1,
0,
0,
0,
681,
677,
1,
0,
0,
0,
682,
103,
1,
0,
0,
0,
683,
684,
7,
9,
0,
0,
684,
105,
1,
0,
0,
0,
685,
686,
3,
90,
45,
0,
686,
687,
5,
87,
0,
0,
687,
700,
1,
0,
0,
0,
688,
689,
3,
92,
46,
0,
689,
690,
5,
87,
0,
0,
690,
700,
1,
0,
0,
0,
691,
692,
7,
1,
0,
0,
692,
694,
5,
87,
0,
0,
693,
695,
3,
98,
49,
0,
694,
693,
1,
0,
0,
0,
694,
695,
1,
0,
0,
0,
695,
700,
1,
0,
0,
0,
696,
697,
3,
96,
48,
0,
697,
698,
5,
87,
0,
0,
698,
700,
1,
0,
0,
0,
699,
685,
1,
0,
0,
0,
699,
688,
1,
0,
0,
0,
699,
691,
1,
0,
0,
0,
699,
696,
1,
0,
0,
0,
700,
107,
1,
0,
0,
0,
701,
706,
3,
106,
53,
0,
702,
703,
5,
59,
0,
0,
703,
705,
3,
106,
53,
0,
704,
702,
1,
0,
0,
0,
705,
708,
1,
0,
0,
0,
706,
704,
1,
0,
0,
0,
706,
707,
1,
0,
0,
0,
707,
710,
1,
0,
0,
0,
708,
706,
1,
0,
0,
0,
709,
711,
5,
59,
0,
0,
710,
709,
1,
0,
0,
0,
710,
711,
1,
0,
0,
0,
711,
109,
1,
0,
0,
0,
712,
717,
3,
68,
34,
0,
713,
714,
5,
59,
0,
0,
714,
716,
3,
68,
34,
0,
715,
713,
1,
0,
0,
0,
716,
719,
1,
0,
0,
0,
717,
715,
1,
0,
0,
0,
717,
718,
1,
0,
0,
0,
718,
721,
1,
0,
0,
0,
719,
717,
1,
0,
0,
0,
720,
722,
5,
59,
0,
0,
721,
720,
1,
0,
0,
0,
721,
722,
1,
0,
0,
0,
722,
111,
1,
0,
0,
0,
723,
728,
3,
104,
52,
0,
724,
725,
5,
59,
0,
0,
725,
727,
3,
104,
52,
0,
726,
724,
1,
0,
0,
0,
727,
730,
1,
0,
0,
0,
728,
726,
1,
0,
0,
0,
728,
729,
1,
0,
0,
0,
729,
732,
1,
0,
0,
0,
730,
728,
1,
0,
0,
0,
731,
733,
5,
59,
0,
0,
732,
731,
1,
0,
0,
0,
732,
733,
1,
0,
0,
0,
733,
113,
1,
0,
0,
0,
734,
739,
5,
87,
0,
0,
735,
736,
5,
59,
0,
0,
736,
738,
5,
87,
0,
0,
737,
735,
1,
0,
0,
0,
738,
741,
1,
0,
0,
0,
739,
737,
1,
0,
0,
0,
739,
740,
1,
0,
0,
0,
740,
743,
1,
0,
0,
0,
741,
739,
1,
0,
0,
0,
742,
744,
5,
59,
0,
0,
743,
742,
1,
0,
0,
0,
743,
744,
1,
0,
0,
0,
744,
115,
1,
0,
0,
0,
745,
750,
3,
100,
50,
0,
746,
747,
5,
59,
0,
0,
747,
749,
3,
100,
50,
0,
748,
746,
1,
0,
0,
0,
749,
752,
1,
0,
0,
0,
750,
748,
1,
0,
0,
0,
750,
751,
1,
0,
0,
0,
751,
754,
1,
0,
0,
0,
752,
750,
1,
0,
0,
0,
753,
755,
5,
59,
0,
0,
754,
753,
1,
0,
0,
0,
754,
755,
1,
0,
0,
0,
755,
117,
1,
0,
0,
0,
756,
761,
3,
102,
51,
0,
757,
758,
5,
59,
0,
0,
758,
760,
3,
102,
51,
0,
759,
757,
1,
0,
0,
0,
760,
763,
1,
0,
0,
0,
761,
759,
1,
0,
0,
0,
761,
762,
1,
0,
0,
0,
762,
765,
1,
0,
0,
0,
763,
761,
1,
0,
0,
0,
764,
766,
5,
59,
0,
0,
765,
764,
1,
0,
0,
0,
765,
766,
1,
0,
0,
0,
766,
119,
1,
0,
0,
0,
90,
121,
126,
139,
169,
171,
175,
181,
191,
220,
231,
236,
248,
254,
261,
268,
274,
277,
280,
288,
294,
297,
300,
303,
306,
311,
327,
332,
346,
354,
366,
370,
378,
382,
390,
393,
402,
413,
416,
420,
426,
440,
454,
458,
495,
497,
505,
511,
517,
521,
525,
533,
537,
544,
549,
553,
557,
565,
570,
574,
578,
580,
588,
605,
607,
613,
617,
621,
625,
629,
639,
641,
645,
663,
673,
679,
681,
694,
699,
706,
710,
717,
721,
728,
732,
739,
743,
750,
754,
761,
765,
]
[docs]
class qasm3Parser(Parser):
grammarFileName = "qasm3Parser.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
sharedContextCache = PredictionContextCache()
literalNames = [
"<INVALID>",
"'OPENQASM'",
"'include'",
"'defcalgrammar'",
"'def'",
"'defcal'",
"'gate'",
"'extern'",
"'box'",
"'let'",
"'break'",
"'continue'",
"'if'",
"'else'",
"'end'",
"'return'",
"'for'",
"'while'",
"'in'",
"<INVALID>",
"<INVALID>",
"'input'",
"'output'",
"'const'",
"'mutable'",
"'qreg'",
"'qubit'",
"'creg'",
"'bool'",
"'bit'",
"'int'",
"'uint'",
"'float'",
"'angle'",
"'complex'",
"'array'",
"'duration'",
"'stretch'",
"'gphase'",
"'inv'",
"'pow'",
"'ctrl'",
"'negctrl'",
"'#dim'",
"'durationof'",
"'delay'",
"'reset'",
"'measure'",
"'barrier'",
"<INVALID>",
"'['",
"']'",
"'{'",
"'}'",
"'('",
"')'",
"':'",
"';'",
"'.'",
"','",
"'='",
"'->'",
"'+'",
"'++'",
"'-'",
"'*'",
"'**'",
"'/'",
"'%'",
"'|'",
"'||'",
"'&'",
"'&&'",
"'^'",
"'@'",
"'~'",
"'!'",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"<INVALID>",
"'im'",
]
symbolicNames = [
"<INVALID>",
"OPENQASM",
"INCLUDE",
"DEFCALGRAMMAR",
"DEF",
"DEFCAL",
"GATE",
"EXTERN",
"BOX",
"LET",
"BREAK",
"CONTINUE",
"IF",
"ELSE",
"END",
"RETURN",
"FOR",
"WHILE",
"IN",
"PRAGMA",
"AnnotationKeyword",
"INPUT",
"OUTPUT",
"CONST",
"MUTABLE",
"QREG",
"QUBIT",
"CREG",
"BOOL",
"BIT",
"INT",
"UINT",
"FLOAT",
"ANGLE",
"COMPLEX",
"ARRAY",
"DURATION",
"STRETCH",
"GPHASE",
"INV",
"POW",
"CTRL",
"NEGCTRL",
"DIM",
"DURATIONOF",
"DELAY",
"RESET",
"MEASURE",
"BARRIER",
"BooleanLiteral",
"LBRACKET",
"RBRACKET",
"LBRACE",
"RBRACE",
"LPAREN",
"RPAREN",
"COLON",
"SEMICOLON",
"DOT",
"COMMA",
"EQUALS",
"ARROW",
"PLUS",
"DOUBLE_PLUS",
"MINUS",
"ASTERISK",
"DOUBLE_ASTERISK",
"SLASH",
"PERCENT",
"PIPE",
"DOUBLE_PIPE",
"AMPERSAND",
"DOUBLE_AMPERSAND",
"CARET",
"AT",
"TILDE",
"EXCLAMATION_POINT",
"EqualityOperator",
"CompoundAssignmentOperator",
"ComparisonOperator",
"BitshiftOperator",
"IMAG",
"ImaginaryLiteral",
"BinaryIntegerLiteral",
"OctalIntegerLiteral",
"DecimalIntegerLiteral",
"HexIntegerLiteral",
"Identifier",
"HardwareQubit",
"FloatLiteral",
"TimingLiteral",
"BitstringLiteral",
"StringLiteral",
"Whitespace",
"Newline",
"LineComment",
"BlockComment",
"VERSION_IDENTIFER_WHITESPACE",
"VersionSpecifier",
"EAT_INITIAL_SPACE",
"EAT_LINE_END",
"RemainingLineContent",
]
RULE_program = 0
RULE_version = 1
RULE_statement = 2
RULE_annotation = 3
RULE_scope = 4
RULE_pragma = 5
RULE_statementOrScope = 6
RULE_calibrationGrammarStatement = 7
RULE_includeStatement = 8
RULE_breakStatement = 9
RULE_continueStatement = 10
RULE_endStatement = 11
RULE_forStatement = 12
RULE_ifStatement = 13
RULE_returnStatement = 14
RULE_whileStatement = 15
RULE_barrierStatement = 16
RULE_boxStatement = 17
RULE_delayStatement = 18
RULE_gateCallStatement = 19
RULE_measureArrowAssignmentStatement = 20
RULE_resetStatement = 21
RULE_aliasDeclarationStatement = 22
RULE_classicalDeclarationStatement = 23
RULE_constDeclarationStatement = 24
RULE_ioDeclarationStatement = 25
RULE_oldStyleDeclarationStatement = 26
RULE_quantumDeclarationStatement = 27
RULE_defStatement = 28
RULE_externStatement = 29
RULE_gateStatement = 30
RULE_assignmentStatement = 31
RULE_expressionStatement = 32
RULE_defcalStatement = 33
RULE_expression = 34
RULE_aliasExpression = 35
RULE_declarationExpression = 36
RULE_measureExpression = 37
RULE_rangeExpression = 38
RULE_setExpression = 39
RULE_arrayLiteral = 40
RULE_indexOperator = 41
RULE_indexedIdentifier = 42
RULE_returnSignature = 43
RULE_gateModifier = 44
RULE_scalarType = 45
RULE_qubitType = 46
RULE_arrayType = 47
RULE_arrayReferenceType = 48
RULE_designator = 49
RULE_gateOperand = 50
RULE_externArgument = 51
RULE_defcalArgument = 52
RULE_argumentDefinition = 53
RULE_argumentDefinitionList = 54
RULE_expressionList = 55
RULE_defcalArgumentList = 56
RULE_identifierList = 57
RULE_gateOperandList = 58
RULE_externArgumentList = 59
ruleNames = [
"program",
"version",
"statement",
"annotation",
"scope",
"pragma",
"statementOrScope",
"calibrationGrammarStatement",
"includeStatement",
"breakStatement",
"continueStatement",
"endStatement",
"forStatement",
"ifStatement",
"returnStatement",
"whileStatement",
"barrierStatement",
"boxStatement",
"delayStatement",
"gateCallStatement",
"measureArrowAssignmentStatement",
"resetStatement",
"aliasDeclarationStatement",
"classicalDeclarationStatement",
"constDeclarationStatement",
"ioDeclarationStatement",
"oldStyleDeclarationStatement",
"quantumDeclarationStatement",
"defStatement",
"externStatement",
"gateStatement",
"assignmentStatement",
"expressionStatement",
"defcalStatement",
"expression",
"aliasExpression",
"declarationExpression",
"measureExpression",
"rangeExpression",
"setExpression",
"arrayLiteral",
"indexOperator",
"indexedIdentifier",
"returnSignature",
"gateModifier",
"scalarType",
"qubitType",
"arrayType",
"arrayReferenceType",
"designator",
"gateOperand",
"externArgument",
"defcalArgument",
"argumentDefinition",
"argumentDefinitionList",
"expressionList",
"defcalArgumentList",
"identifierList",
"gateOperandList",
"externArgumentList",
]
EOF = Token.EOF
OPENQASM = 1
INCLUDE = 2
DEFCALGRAMMAR = 3
DEF = 4
DEFCAL = 5
GATE = 6
EXTERN = 7
BOX = 8
LET = 9
BREAK = 10
CONTINUE = 11
IF = 12
ELSE = 13
END = 14
RETURN = 15
FOR = 16
WHILE = 17
IN = 18
PRAGMA = 19
AnnotationKeyword = 20
INPUT = 21
OUTPUT = 22
CONST = 23
MUTABLE = 24
QREG = 25
QUBIT = 26
CREG = 27
BOOL = 28
BIT = 29
INT = 30
UINT = 31
FLOAT = 32
ANGLE = 33
COMPLEX = 34
ARRAY = 35
DURATION = 36
STRETCH = 37
GPHASE = 38
INV = 39
POW = 40
CTRL = 41
NEGCTRL = 42
DIM = 43
DURATIONOF = 44
DELAY = 45
RESET = 46
MEASURE = 47
BARRIER = 48
BooleanLiteral = 49
LBRACKET = 50
RBRACKET = 51
LBRACE = 52
RBRACE = 53
LPAREN = 54
RPAREN = 55
COLON = 56
SEMICOLON = 57
DOT = 58
COMMA = 59
EQUALS = 60
ARROW = 61
PLUS = 62
DOUBLE_PLUS = 63
MINUS = 64
ASTERISK = 65
DOUBLE_ASTERISK = 66
SLASH = 67
PERCENT = 68
PIPE = 69
DOUBLE_PIPE = 70
AMPERSAND = 71
DOUBLE_AMPERSAND = 72
CARET = 73
AT = 74
TILDE = 75
EXCLAMATION_POINT = 76
EqualityOperator = 77
CompoundAssignmentOperator = 78
ComparisonOperator = 79
BitshiftOperator = 80
IMAG = 81
ImaginaryLiteral = 82
BinaryIntegerLiteral = 83
OctalIntegerLiteral = 84
DecimalIntegerLiteral = 85
HexIntegerLiteral = 86
Identifier = 87
HardwareQubit = 88
FloatLiteral = 89
TimingLiteral = 90
BitstringLiteral = 91
StringLiteral = 92
Whitespace = 93
Newline = 94
LineComment = 95
BlockComment = 96
VERSION_IDENTIFER_WHITESPACE = 97
VersionSpecifier = 98
EAT_INITIAL_SPACE = 99
EAT_LINE_END = 100
RemainingLineContent = 101
def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.13.2")
self._interp = ParserATNSimulator(
self, self.atn, self.decisionsToDFA, self.sharedContextCache
)
self._predicates = None
[docs]
class ProgramContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EOF(self):
return self.getToken(qasm3Parser.EOF, 0)
[docs]
def version(self):
return self.getTypedRuleContext(qasm3Parser.VersionContext, 0)
[docs]
def statement(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.StatementContext)
else:
return self.getTypedRuleContext(qasm3Parser.StatementContext, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_program
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterProgram"):
listener.enterProgram(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitProgram"):
listener.exitProgram(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitProgram"):
return visitor.visitProgram(self)
else:
return visitor.visitChildren(self)
[docs]
def program(self):
localctx = qasm3Parser.ProgramContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_program)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 121
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 1:
self.state = 120
self.version()
self.state = 126
self._errHandler.sync(self)
_la = self._input.LA(1)
while (((_la) & ~0x3F) == 0 and ((1 << _la) & 19131502306254844) != 0) or (
((_la - 64) & ~0x3F) == 0 and ((1 << (_la - 64)) & 268179457) != 0
):
self.state = 123
self.statement()
self.state = 128
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 129
self.match(qasm3Parser.EOF)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VersionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OPENQASM(self):
return self.getToken(qasm3Parser.OPENQASM, 0)
[docs]
def VersionSpecifier(self):
return self.getToken(qasm3Parser.VersionSpecifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_version
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterVersion"):
listener.enterVersion(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitVersion"):
listener.exitVersion(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitVersion"):
return visitor.visitVersion(self)
else:
return visitor.visitChildren(self)
[docs]
def version(self):
localctx = qasm3Parser.VersionContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_version)
try:
self.enterOuterAlt(localctx, 1)
self.state = 131
self.match(qasm3Parser.OPENQASM)
self.state = 132
self.match(qasm3Parser.VersionSpecifier)
self.state = 133
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def pragma(self):
return self.getTypedRuleContext(qasm3Parser.PragmaContext, 0)
[docs]
def aliasDeclarationStatement(self):
return self.getTypedRuleContext(qasm3Parser.AliasDeclarationStatementContext, 0)
[docs]
def assignmentStatement(self):
return self.getTypedRuleContext(qasm3Parser.AssignmentStatementContext, 0)
[docs]
def barrierStatement(self):
return self.getTypedRuleContext(qasm3Parser.BarrierStatementContext, 0)
[docs]
def boxStatement(self):
return self.getTypedRuleContext(qasm3Parser.BoxStatementContext, 0)
[docs]
def breakStatement(self):
return self.getTypedRuleContext(qasm3Parser.BreakStatementContext, 0)
[docs]
def calibrationGrammarStatement(self):
return self.getTypedRuleContext(qasm3Parser.CalibrationGrammarStatementContext, 0)
[docs]
def classicalDeclarationStatement(self):
return self.getTypedRuleContext(qasm3Parser.ClassicalDeclarationStatementContext, 0)
[docs]
def constDeclarationStatement(self):
return self.getTypedRuleContext(qasm3Parser.ConstDeclarationStatementContext, 0)
[docs]
def continueStatement(self):
return self.getTypedRuleContext(qasm3Parser.ContinueStatementContext, 0)
[docs]
def defStatement(self):
return self.getTypedRuleContext(qasm3Parser.DefStatementContext, 0)
[docs]
def defcalStatement(self):
return self.getTypedRuleContext(qasm3Parser.DefcalStatementContext, 0)
[docs]
def delayStatement(self):
return self.getTypedRuleContext(qasm3Parser.DelayStatementContext, 0)
[docs]
def endStatement(self):
return self.getTypedRuleContext(qasm3Parser.EndStatementContext, 0)
[docs]
def expressionStatement(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionStatementContext, 0)
[docs]
def externStatement(self):
return self.getTypedRuleContext(qasm3Parser.ExternStatementContext, 0)
[docs]
def forStatement(self):
return self.getTypedRuleContext(qasm3Parser.ForStatementContext, 0)
[docs]
def gateCallStatement(self):
return self.getTypedRuleContext(qasm3Parser.GateCallStatementContext, 0)
[docs]
def gateStatement(self):
return self.getTypedRuleContext(qasm3Parser.GateStatementContext, 0)
[docs]
def ifStatement(self):
return self.getTypedRuleContext(qasm3Parser.IfStatementContext, 0)
[docs]
def includeStatement(self):
return self.getTypedRuleContext(qasm3Parser.IncludeStatementContext, 0)
[docs]
def ioDeclarationStatement(self):
return self.getTypedRuleContext(qasm3Parser.IoDeclarationStatementContext, 0)
[docs]
def measureArrowAssignmentStatement(self):
return self.getTypedRuleContext(qasm3Parser.MeasureArrowAssignmentStatementContext, 0)
[docs]
def oldStyleDeclarationStatement(self):
return self.getTypedRuleContext(qasm3Parser.OldStyleDeclarationStatementContext, 0)
[docs]
def quantumDeclarationStatement(self):
return self.getTypedRuleContext(qasm3Parser.QuantumDeclarationStatementContext, 0)
[docs]
def resetStatement(self):
return self.getTypedRuleContext(qasm3Parser.ResetStatementContext, 0)
[docs]
def returnStatement(self):
return self.getTypedRuleContext(qasm3Parser.ReturnStatementContext, 0)
[docs]
def whileStatement(self):
return self.getTypedRuleContext(qasm3Parser.WhileStatementContext, 0)
[docs]
def annotation(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.AnnotationContext)
else:
return self.getTypedRuleContext(qasm3Parser.AnnotationContext, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_statement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterStatement"):
listener.enterStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitStatement"):
listener.exitStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitStatement"):
return visitor.visitStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def statement(self):
localctx = qasm3Parser.StatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_statement)
self._la = 0 # Token type
try:
self.state = 171
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [19]:
self.enterOuterAlt(localctx, 1)
self.state = 135
self.pragma()
pass
elif token in [
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
14,
15,
16,
17,
20,
21,
22,
23,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
44,
45,
46,
47,
48,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.enterOuterAlt(localctx, 2)
self.state = 139
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 20:
self.state = 136
self.annotation()
self.state = 141
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 169
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 3, self._ctx)
if la_ == 1:
self.state = 142
self.aliasDeclarationStatement()
pass
elif la_ == 2:
self.state = 143
self.assignmentStatement()
pass
elif la_ == 3:
self.state = 144
self.barrierStatement()
pass
elif la_ == 4:
self.state = 145
self.boxStatement()
pass
elif la_ == 5:
self.state = 146
self.breakStatement()
pass
elif la_ == 6:
self.state = 147
self.calibrationGrammarStatement()
pass
elif la_ == 7:
self.state = 148
self.classicalDeclarationStatement()
pass
elif la_ == 8:
self.state = 149
self.constDeclarationStatement()
pass
elif la_ == 9:
self.state = 150
self.continueStatement()
pass
elif la_ == 10:
self.state = 151
self.defStatement()
pass
elif la_ == 11:
self.state = 152
self.defcalStatement()
pass
elif la_ == 12:
self.state = 153
self.delayStatement()
pass
elif la_ == 13:
self.state = 154
self.endStatement()
pass
elif la_ == 14:
self.state = 155
self.expressionStatement()
pass
elif la_ == 15:
self.state = 156
self.externStatement()
pass
elif la_ == 16:
self.state = 157
self.forStatement()
pass
elif la_ == 17:
self.state = 158
self.gateCallStatement()
pass
elif la_ == 18:
self.state = 159
self.gateStatement()
pass
elif la_ == 19:
self.state = 160
self.ifStatement()
pass
elif la_ == 20:
self.state = 161
self.includeStatement()
pass
elif la_ == 21:
self.state = 162
self.ioDeclarationStatement()
pass
elif la_ == 22:
self.state = 163
self.measureArrowAssignmentStatement()
pass
elif la_ == 23:
self.state = 164
self.oldStyleDeclarationStatement()
pass
elif la_ == 24:
self.state = 165
self.quantumDeclarationStatement()
pass
elif la_ == 25:
self.state = 166
self.resetStatement()
pass
elif la_ == 26:
self.state = 167
self.returnStatement()
pass
elif la_ == 27:
self.state = 168
self.whileStatement()
pass
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
[docs]
class AnnotationContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def AnnotationKeyword(self):
return self.getToken(qasm3Parser.AnnotationKeyword, 0)
[docs]
def RemainingLineContent(self):
return self.getToken(qasm3Parser.RemainingLineContent, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_annotation
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterAnnotation"):
listener.enterAnnotation(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitAnnotation"):
listener.exitAnnotation(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAnnotation"):
return visitor.visitAnnotation(self)
else:
return visitor.visitChildren(self)
[docs]
def annotation(self):
localctx = qasm3Parser.AnnotationContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_annotation)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 173
self.match(qasm3Parser.AnnotationKeyword)
self.state = 175
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 101:
self.state = 174
self.match(qasm3Parser.RemainingLineContent)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ScopeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LBRACE(self):
return self.getToken(qasm3Parser.LBRACE, 0)
[docs]
def RBRACE(self):
return self.getToken(qasm3Parser.RBRACE, 0)
[docs]
def statement(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.StatementContext)
else:
return self.getTypedRuleContext(qasm3Parser.StatementContext, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_scope
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterScope"):
listener.enterScope(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitScope"):
listener.exitScope(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitScope"):
return visitor.visitScope(self)
else:
return visitor.visitChildren(self)
[docs]
def scope(self):
localctx = qasm3Parser.ScopeContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_scope)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 177
self.match(qasm3Parser.LBRACE)
self.state = 181
self._errHandler.sync(self)
_la = self._input.LA(1)
while (((_la) & ~0x3F) == 0 and ((1 << _la) & 19131502306254844) != 0) or (
((_la - 64) & ~0x3F) == 0 and ((1 << (_la - 64)) & 268179457) != 0
):
self.state = 178
self.statement()
self.state = 183
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 184
self.match(qasm3Parser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class PragmaContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PRAGMA(self):
return self.getToken(qasm3Parser.PRAGMA, 0)
[docs]
def RemainingLineContent(self):
return self.getToken(qasm3Parser.RemainingLineContent, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_pragma
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterPragma"):
listener.enterPragma(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitPragma"):
listener.exitPragma(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitPragma"):
return visitor.visitPragma(self)
else:
return visitor.visitChildren(self)
[docs]
def pragma(self):
localctx = qasm3Parser.PragmaContext(self, self._ctx, self.state)
self.enterRule(localctx, 10, self.RULE_pragma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 186
self.match(qasm3Parser.PRAGMA)
self.state = 187
self.match(qasm3Parser.RemainingLineContent)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StatementOrScopeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def statement(self):
return self.getTypedRuleContext(qasm3Parser.StatementContext, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(qasm3Parser.ScopeContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_statementOrScope
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterStatementOrScope"):
listener.enterStatementOrScope(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitStatementOrScope"):
listener.exitStatementOrScope(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitStatementOrScope"):
return visitor.visitStatementOrScope(self)
else:
return visitor.visitChildren(self)
[docs]
def statementOrScope(self):
localctx = qasm3Parser.StatementOrScopeContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_statementOrScope)
try:
self.state = 191
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
14,
15,
16,
17,
19,
20,
21,
22,
23,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
44,
45,
46,
47,
48,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.enterOuterAlt(localctx, 1)
self.state = 189
self.statement()
pass
elif token in [52]:
self.enterOuterAlt(localctx, 2)
self.state = 190
self.scope()
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
[docs]
class CalibrationGrammarStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DEFCALGRAMMAR(self):
return self.getToken(qasm3Parser.DEFCALGRAMMAR, 0)
[docs]
def StringLiteral(self):
return self.getToken(qasm3Parser.StringLiteral, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_calibrationGrammarStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterCalibrationGrammarStatement"):
listener.enterCalibrationGrammarStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitCalibrationGrammarStatement"):
listener.exitCalibrationGrammarStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitCalibrationGrammarStatement"):
return visitor.visitCalibrationGrammarStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def calibrationGrammarStatement(self):
localctx = qasm3Parser.CalibrationGrammarStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_calibrationGrammarStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 193
self.match(qasm3Parser.DEFCALGRAMMAR)
self.state = 194
self.match(qasm3Parser.StringLiteral)
self.state = 195
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IncludeStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def INCLUDE(self):
return self.getToken(qasm3Parser.INCLUDE, 0)
[docs]
def StringLiteral(self):
return self.getToken(qasm3Parser.StringLiteral, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_includeStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterIncludeStatement"):
listener.enterIncludeStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitIncludeStatement"):
listener.exitIncludeStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIncludeStatement"):
return visitor.visitIncludeStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def includeStatement(self):
localctx = qasm3Parser.IncludeStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_includeStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 197
self.match(qasm3Parser.INCLUDE)
self.state = 198
self.match(qasm3Parser.StringLiteral)
self.state = 199
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BreakStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BREAK(self):
return self.getToken(qasm3Parser.BREAK, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_breakStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterBreakStatement"):
listener.enterBreakStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitBreakStatement"):
listener.exitBreakStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBreakStatement"):
return visitor.visitBreakStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def breakStatement(self):
localctx = qasm3Parser.BreakStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_breakStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 201
self.match(qasm3Parser.BREAK)
self.state = 202
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ContinueStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CONTINUE(self):
return self.getToken(qasm3Parser.CONTINUE, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_continueStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterContinueStatement"):
listener.enterContinueStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitContinueStatement"):
listener.exitContinueStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitContinueStatement"):
return visitor.visitContinueStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def continueStatement(self):
localctx = qasm3Parser.ContinueStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_continueStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 204
self.match(qasm3Parser.CONTINUE)
self.state = 205
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class EndStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def END(self):
return self.getToken(qasm3Parser.END, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_endStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterEndStatement"):
listener.enterEndStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitEndStatement"):
listener.exitEndStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitEndStatement"):
return visitor.visitEndStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def endStatement(self):
localctx = qasm3Parser.EndStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_endStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 207
self.match(qasm3Parser.END)
self.state = 208
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ForStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
self.body = None # StatementOrScopeContext
[docs]
def FOR(self):
return self.getToken(qasm3Parser.FOR, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def Identifier(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.Identifier)
else:
return self.getToken(qasm3Parser.Identifier, i)
[docs]
def IN(self):
return self.getToken(qasm3Parser.IN, 0)
[docs]
def statementOrScope(self):
return self.getTypedRuleContext(qasm3Parser.StatementOrScopeContext, 0)
[docs]
def setExpression(self):
return self.getTypedRuleContext(qasm3Parser.SetExpressionContext, 0)
[docs]
def LBRACKET(self):
return self.getToken(qasm3Parser.LBRACKET, 0)
[docs]
def rangeExpression(self):
return self.getTypedRuleContext(qasm3Parser.RangeExpressionContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(qasm3Parser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_forStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterForStatement"):
listener.enterForStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitForStatement"):
listener.exitForStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitForStatement"):
return visitor.visitForStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def forStatement(self):
localctx = qasm3Parser.ForStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_forStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 210
self.match(qasm3Parser.FOR)
self.state = 211
self.scalarType()
self.state = 212
self.match(qasm3Parser.Identifier)
self.state = 213
self.match(qasm3Parser.IN)
self.state = 220
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [52]:
self.state = 214
self.setExpression()
pass
elif token in [50]:
self.state = 215
self.match(qasm3Parser.LBRACKET)
self.state = 216
self.rangeExpression()
self.state = 217
self.match(qasm3Parser.RBRACKET)
pass
elif token in [87]:
self.state = 219
self.match(qasm3Parser.Identifier)
pass
else:
raise NoViableAltException(self)
self.state = 222
localctx.body = self.statementOrScope()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IfStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
self.if_body = None # StatementOrScopeContext
self.else_body = None # StatementOrScopeContext
[docs]
def IF(self):
return self.getToken(qasm3Parser.IF, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def statementOrScope(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.StatementOrScopeContext)
else:
return self.getTypedRuleContext(qasm3Parser.StatementOrScopeContext, i)
[docs]
def ELSE(self):
return self.getToken(qasm3Parser.ELSE, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_ifStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterIfStatement"):
listener.enterIfStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitIfStatement"):
listener.exitIfStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIfStatement"):
return visitor.visitIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def ifStatement(self):
localctx = qasm3Parser.IfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_ifStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 224
self.match(qasm3Parser.IF)
self.state = 225
self.match(qasm3Parser.LPAREN)
self.state = 226
self.expression(0)
self.state = 227
self.match(qasm3Parser.RPAREN)
self.state = 228
localctx.if_body = self.statementOrScope()
self.state = 231
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 9, self._ctx)
if la_ == 1:
self.state = 229
self.match(qasm3Parser.ELSE)
self.state = 230
localctx.else_body = self.statementOrScope()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ReturnStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def RETURN(self):
return self.getToken(qasm3Parser.RETURN, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def measureExpression(self):
return self.getTypedRuleContext(qasm3Parser.MeasureExpressionContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_returnStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterReturnStatement"):
listener.enterReturnStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitReturnStatement"):
listener.exitReturnStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitReturnStatement"):
return visitor.visitReturnStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def returnStatement(self):
localctx = qasm3Parser.ReturnStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_returnStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 233
self.match(qasm3Parser.RETURN)
self.state = 236
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
44,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.state = 234
self.expression(0)
pass
elif token in [47]:
self.state = 235
self.measureExpression()
pass
elif token in [57]:
pass
else:
pass
self.state = 238
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class WhileStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
self.body = None # StatementOrScopeContext
[docs]
def WHILE(self):
return self.getToken(qasm3Parser.WHILE, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def statementOrScope(self):
return self.getTypedRuleContext(qasm3Parser.StatementOrScopeContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_whileStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterWhileStatement"):
listener.enterWhileStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitWhileStatement"):
listener.exitWhileStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitWhileStatement"):
return visitor.visitWhileStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def whileStatement(self):
localctx = qasm3Parser.WhileStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_whileStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 240
self.match(qasm3Parser.WHILE)
self.state = 241
self.match(qasm3Parser.LPAREN)
self.state = 242
self.expression(0)
self.state = 243
self.match(qasm3Parser.RPAREN)
self.state = 244
localctx.body = self.statementOrScope()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BarrierStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BARRIER(self):
return self.getToken(qasm3Parser.BARRIER, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def gateOperandList(self):
return self.getTypedRuleContext(qasm3Parser.GateOperandListContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_barrierStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterBarrierStatement"):
listener.enterBarrierStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitBarrierStatement"):
listener.exitBarrierStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBarrierStatement"):
return visitor.visitBarrierStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def barrierStatement(self):
localctx = qasm3Parser.BarrierStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_barrierStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 246
self.match(qasm3Parser.BARRIER)
self.state = 248
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 87 or _la == 88:
self.state = 247
self.gateOperandList()
self.state = 250
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BoxStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BOX(self):
return self.getToken(qasm3Parser.BOX, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(qasm3Parser.ScopeContext, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_boxStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterBoxStatement"):
listener.enterBoxStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitBoxStatement"):
listener.exitBoxStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBoxStatement"):
return visitor.visitBoxStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def boxStatement(self):
localctx = qasm3Parser.BoxStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 34, self.RULE_boxStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 252
self.match(qasm3Parser.BOX)
self.state = 254
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 253
self.designator()
self.state = 256
self.scope()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DelayStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DELAY(self):
return self.getToken(qasm3Parser.DELAY, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def gateOperandList(self):
return self.getTypedRuleContext(qasm3Parser.GateOperandListContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_delayStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDelayStatement"):
listener.enterDelayStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDelayStatement"):
listener.exitDelayStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDelayStatement"):
return visitor.visitDelayStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def delayStatement(self):
localctx = qasm3Parser.DelayStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 36, self.RULE_delayStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 258
self.match(qasm3Parser.DELAY)
self.state = 259
self.designator()
self.state = 261
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 87 or _la == 88:
self.state = 260
self.gateOperandList()
self.state = 263
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class GateCallStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def gateOperandList(self):
return self.getTypedRuleContext(qasm3Parser.GateOperandListContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def gateModifier(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.GateModifierContext)
else:
return self.getTypedRuleContext(qasm3Parser.GateModifierContext, i)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionListContext, 0)
[docs]
def GPHASE(self):
return self.getToken(qasm3Parser.GPHASE, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_gateCallStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterGateCallStatement"):
listener.enterGateCallStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitGateCallStatement"):
listener.exitGateCallStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateCallStatement"):
return visitor.visitGateCallStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def gateCallStatement(self):
localctx = qasm3Parser.GateCallStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 38, self.RULE_gateCallStatement)
self._la = 0 # Token type
try:
self.state = 306
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 23, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 268
self._errHandler.sync(self)
_la = self._input.LA(1)
while ((_la) & ~0x3F) == 0 and ((1 << _la) & 8246337208320) != 0:
self.state = 265
self.gateModifier()
self.state = 270
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 271
self.match(qasm3Parser.Identifier)
self.state = 277
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 54:
self.state = 272
self.match(qasm3Parser.LPAREN)
self.state = 274
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 28) & ~0x3F) == 0 and ((1 << (_la - 28)) & -17592117255666689) != 0:
self.state = 273
self.expressionList()
self.state = 276
self.match(qasm3Parser.RPAREN)
self.state = 280
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 279
self.designator()
self.state = 282
self.gateOperandList()
self.state = 283
self.match(qasm3Parser.SEMICOLON)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 288
self._errHandler.sync(self)
_la = self._input.LA(1)
while ((_la) & ~0x3F) == 0 and ((1 << _la) & 8246337208320) != 0:
self.state = 285
self.gateModifier()
self.state = 290
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 291
self.match(qasm3Parser.GPHASE)
self.state = 297
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 54:
self.state = 292
self.match(qasm3Parser.LPAREN)
self.state = 294
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 28) & ~0x3F) == 0 and ((1 << (_la - 28)) & -17592117255666689) != 0:
self.state = 293
self.expressionList()
self.state = 296
self.match(qasm3Parser.RPAREN)
self.state = 300
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 299
self.designator()
self.state = 303
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 87 or _la == 88:
self.state = 302
self.gateOperandList()
self.state = 305
self.match(qasm3Parser.SEMICOLON)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MeasureArrowAssignmentStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def measureExpression(self):
return self.getTypedRuleContext(qasm3Parser.MeasureExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def ARROW(self):
return self.getToken(qasm3Parser.ARROW, 0)
[docs]
def indexedIdentifier(self):
return self.getTypedRuleContext(qasm3Parser.IndexedIdentifierContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_measureArrowAssignmentStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterMeasureArrowAssignmentStatement"):
listener.enterMeasureArrowAssignmentStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitMeasureArrowAssignmentStatement"):
listener.exitMeasureArrowAssignmentStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMeasureArrowAssignmentStatement"):
return visitor.visitMeasureArrowAssignmentStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def measureArrowAssignmentStatement(self):
localctx = qasm3Parser.MeasureArrowAssignmentStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_measureArrowAssignmentStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 308
self.measureExpression()
self.state = 311
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 61:
self.state = 309
self.match(qasm3Parser.ARROW)
self.state = 310
self.indexedIdentifier()
self.state = 313
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ResetStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def RESET(self):
return self.getToken(qasm3Parser.RESET, 0)
[docs]
def gateOperand(self):
return self.getTypedRuleContext(qasm3Parser.GateOperandContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_resetStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterResetStatement"):
listener.enterResetStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitResetStatement"):
listener.exitResetStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitResetStatement"):
return visitor.visitResetStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def resetStatement(self):
localctx = qasm3Parser.ResetStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 42, self.RULE_resetStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 315
self.match(qasm3Parser.RESET)
self.state = 316
self.gateOperand()
self.state = 317
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AliasDeclarationStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LET(self):
return self.getToken(qasm3Parser.LET, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def EQUALS(self):
return self.getToken(qasm3Parser.EQUALS, 0)
[docs]
def aliasExpression(self):
return self.getTypedRuleContext(qasm3Parser.AliasExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_aliasDeclarationStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterAliasDeclarationStatement"):
listener.enterAliasDeclarationStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitAliasDeclarationStatement"):
listener.exitAliasDeclarationStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAliasDeclarationStatement"):
return visitor.visitAliasDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def aliasDeclarationStatement(self):
localctx = qasm3Parser.AliasDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_aliasDeclarationStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 319
self.match(qasm3Parser.LET)
self.state = 320
self.match(qasm3Parser.Identifier)
self.state = 321
self.match(qasm3Parser.EQUALS)
self.state = 322
self.aliasExpression()
self.state = 323
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassicalDeclarationStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def arrayType(self):
return self.getTypedRuleContext(qasm3Parser.ArrayTypeContext, 0)
[docs]
def EQUALS(self):
return self.getToken(qasm3Parser.EQUALS, 0)
[docs]
def declarationExpression(self):
return self.getTypedRuleContext(qasm3Parser.DeclarationExpressionContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_classicalDeclarationStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterClassicalDeclarationStatement"):
listener.enterClassicalDeclarationStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitClassicalDeclarationStatement"):
listener.exitClassicalDeclarationStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitClassicalDeclarationStatement"):
return visitor.visitClassicalDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def classicalDeclarationStatement(self):
localctx = qasm3Parser.ClassicalDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_classicalDeclarationStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 327
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [28, 29, 30, 31, 32, 33, 34, 36, 37]:
self.state = 325
self.scalarType()
pass
elif token in [35]:
self.state = 326
self.arrayType()
pass
else:
raise NoViableAltException(self)
self.state = 329
self.match(qasm3Parser.Identifier)
self.state = 332
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 60:
self.state = 330
self.match(qasm3Parser.EQUALS)
self.state = 331
self.declarationExpression()
self.state = 334
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ConstDeclarationStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CONST(self):
return self.getToken(qasm3Parser.CONST, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def EQUALS(self):
return self.getToken(qasm3Parser.EQUALS, 0)
[docs]
def declarationExpression(self):
return self.getTypedRuleContext(qasm3Parser.DeclarationExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_constDeclarationStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterConstDeclarationStatement"):
listener.enterConstDeclarationStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitConstDeclarationStatement"):
listener.exitConstDeclarationStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitConstDeclarationStatement"):
return visitor.visitConstDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def constDeclarationStatement(self):
localctx = qasm3Parser.ConstDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 48, self.RULE_constDeclarationStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 336
self.match(qasm3Parser.CONST)
self.state = 337
self.scalarType()
self.state = 338
self.match(qasm3Parser.Identifier)
self.state = 339
self.match(qasm3Parser.EQUALS)
self.state = 340
self.declarationExpression()
self.state = 341
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IoDeclarationStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def INPUT(self):
return self.getToken(qasm3Parser.INPUT, 0)
[docs]
def OUTPUT(self):
return self.getToken(qasm3Parser.OUTPUT, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def arrayType(self):
return self.getTypedRuleContext(qasm3Parser.ArrayTypeContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_ioDeclarationStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterIoDeclarationStatement"):
listener.enterIoDeclarationStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitIoDeclarationStatement"):
listener.exitIoDeclarationStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIoDeclarationStatement"):
return visitor.visitIoDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def ioDeclarationStatement(self):
localctx = qasm3Parser.IoDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 50, self.RULE_ioDeclarationStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 343
_la = self._input.LA(1)
if not (_la == 21 or _la == 22):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 346
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [28, 29, 30, 31, 32, 33, 34, 36, 37]:
self.state = 344
self.scalarType()
pass
elif token in [35]:
self.state = 345
self.arrayType()
pass
else:
raise NoViableAltException(self)
self.state = 348
self.match(qasm3Parser.Identifier)
self.state = 349
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OldStyleDeclarationStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def CREG(self):
return self.getToken(qasm3Parser.CREG, 0)
[docs]
def QREG(self):
return self.getToken(qasm3Parser.QREG, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_oldStyleDeclarationStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterOldStyleDeclarationStatement"):
listener.enterOldStyleDeclarationStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitOldStyleDeclarationStatement"):
listener.exitOldStyleDeclarationStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitOldStyleDeclarationStatement"):
return visitor.visitOldStyleDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def oldStyleDeclarationStatement(self):
localctx = qasm3Parser.OldStyleDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 52, self.RULE_oldStyleDeclarationStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 351
_la = self._input.LA(1)
if not (_la == 25 or _la == 27):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 352
self.match(qasm3Parser.Identifier)
self.state = 354
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 353
self.designator()
self.state = 356
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class QuantumDeclarationStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def qubitType(self):
return self.getTypedRuleContext(qasm3Parser.QubitTypeContext, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_quantumDeclarationStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterQuantumDeclarationStatement"):
listener.enterQuantumDeclarationStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitQuantumDeclarationStatement"):
listener.exitQuantumDeclarationStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitQuantumDeclarationStatement"):
return visitor.visitQuantumDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def quantumDeclarationStatement(self):
localctx = qasm3Parser.QuantumDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_quantumDeclarationStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 358
self.qubitType()
self.state = 359
self.match(qasm3Parser.Identifier)
self.state = 360
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DefStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DEF(self):
return self.getToken(qasm3Parser.DEF, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(qasm3Parser.ScopeContext, 0)
[docs]
def argumentDefinitionList(self):
return self.getTypedRuleContext(qasm3Parser.ArgumentDefinitionListContext, 0)
[docs]
def returnSignature(self):
return self.getTypedRuleContext(qasm3Parser.ReturnSignatureContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_defStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDefStatement"):
listener.enterDefStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDefStatement"):
listener.exitDefStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefStatement"):
return visitor.visitDefStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def defStatement(self):
localctx = qasm3Parser.DefStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 56, self.RULE_defStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 362
self.match(qasm3Parser.DEF)
self.state = 363
self.match(qasm3Parser.Identifier)
self.state = 364
self.match(qasm3Parser.LPAREN)
self.state = 366
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la) & ~0x3F) == 0 and ((1 << _la) & 240509779968) != 0:
self.state = 365
self.argumentDefinitionList()
self.state = 368
self.match(qasm3Parser.RPAREN)
self.state = 370
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 61:
self.state = 369
self.returnSignature()
self.state = 372
self.scope()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExternStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EXTERN(self):
return self.getToken(qasm3Parser.EXTERN, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def externArgumentList(self):
return self.getTypedRuleContext(qasm3Parser.ExternArgumentListContext, 0)
[docs]
def returnSignature(self):
return self.getTypedRuleContext(qasm3Parser.ReturnSignatureContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_externStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterExternStatement"):
listener.enterExternStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitExternStatement"):
listener.exitExternStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExternStatement"):
return visitor.visitExternStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def externStatement(self):
localctx = qasm3Parser.ExternStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 58, self.RULE_externStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 374
self.match(qasm3Parser.EXTERN)
self.state = 375
self.match(qasm3Parser.Identifier)
self.state = 376
self.match(qasm3Parser.LPAREN)
self.state = 378
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la) & ~0x3F) == 0 and ((1 << _la) & 240409116672) != 0:
self.state = 377
self.externArgumentList()
self.state = 380
self.match(qasm3Parser.RPAREN)
self.state = 382
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 61:
self.state = 381
self.returnSignature()
self.state = 384
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class GateStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
self.params = None # IdentifierListContext
self.qubits = None # IdentifierListContext
[docs]
def GATE(self):
return self.getToken(qasm3Parser.GATE, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(qasm3Parser.ScopeContext, 0)
[docs]
def identifierList(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.IdentifierListContext)
else:
return self.getTypedRuleContext(qasm3Parser.IdentifierListContext, i)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_gateStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterGateStatement"):
listener.enterGateStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitGateStatement"):
listener.exitGateStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateStatement"):
return visitor.visitGateStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def gateStatement(self):
localctx = qasm3Parser.GateStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_gateStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 386
self.match(qasm3Parser.GATE)
self.state = 387
self.match(qasm3Parser.Identifier)
self.state = 393
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 54:
self.state = 388
self.match(qasm3Parser.LPAREN)
self.state = 390
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 87:
self.state = 389
localctx.params = self.identifierList()
self.state = 392
self.match(qasm3Parser.RPAREN)
self.state = 395
localctx.qubits = self.identifierList()
self.state = 396
self.scope()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class AssignmentStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
self.op = None # Token
[docs]
def indexedIdentifier(self):
return self.getTypedRuleContext(qasm3Parser.IndexedIdentifierContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def EQUALS(self):
return self.getToken(qasm3Parser.EQUALS, 0)
[docs]
def CompoundAssignmentOperator(self):
return self.getToken(qasm3Parser.CompoundAssignmentOperator, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def measureExpression(self):
return self.getTypedRuleContext(qasm3Parser.MeasureExpressionContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_assignmentStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterAssignmentStatement"):
listener.enterAssignmentStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitAssignmentStatement"):
listener.exitAssignmentStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAssignmentStatement"):
return visitor.visitAssignmentStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def assignmentStatement(self):
localctx = qasm3Parser.AssignmentStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 62, self.RULE_assignmentStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 398
self.indexedIdentifier()
self.state = 399
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (_la == 60 or _la == 78):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 402
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
44,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.state = 400
self.expression(0)
pass
elif token in [47]:
self.state = 401
self.measureExpression()
pass
else:
raise NoViableAltException(self)
self.state = 404
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExpressionStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(qasm3Parser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_expressionStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterExpressionStatement"):
listener.enterExpressionStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitExpressionStatement"):
listener.exitExpressionStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExpressionStatement"):
return visitor.visitExpressionStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def expressionStatement(self):
localctx = qasm3Parser.ExpressionStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 64, self.RULE_expressionStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 406
self.expression(0)
self.state = 407
self.match(qasm3Parser.SEMICOLON)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DefcalStatementContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DEFCAL(self):
return self.getToken(qasm3Parser.DEFCAL, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def defcalArgumentList(self):
return self.getTypedRuleContext(qasm3Parser.DefcalArgumentListContext, 0)
[docs]
def LBRACE(self):
return self.getToken(qasm3Parser.LBRACE, 0)
[docs]
def RBRACE(self):
return self.getToken(qasm3Parser.RBRACE, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def returnSignature(self):
return self.getTypedRuleContext(qasm3Parser.ReturnSignatureContext, 0)
[docs]
def argumentDefinitionList(self):
return self.getTypedRuleContext(qasm3Parser.ArgumentDefinitionListContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_defcalStatement
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDefcalStatement"):
listener.enterDefcalStatement(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDefcalStatement"):
listener.exitDefcalStatement(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefcalStatement"):
return visitor.visitDefcalStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def defcalStatement(self):
localctx = qasm3Parser.DefcalStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 66, self.RULE_defcalStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 409
self.match(qasm3Parser.DEFCAL)
self.state = 410
self.match(qasm3Parser.Identifier)
self.state = 416
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 54:
self.state = 411
self.match(qasm3Parser.LPAREN)
self.state = 413
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la) & ~0x3F) == 0 and ((1 << _la) & 240509779968) != 0:
self.state = 412
self.argumentDefinitionList()
self.state = 415
self.match(qasm3Parser.RPAREN)
self.state = 418
self.defcalArgumentList()
self.state = 420
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 61:
self.state = 419
self.returnSignature()
self.state = 422
self.match(qasm3Parser.LBRACE)
self.state = 426
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 39, self._ctx)
while _alt != 1 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1 + 1:
self.state = 423
self.matchWildcard()
self.state = 428
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 39, self._ctx)
self.state = 429
self.match(qasm3Parser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExpressionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_expression
[docs]
def copyFrom(self, ctx: ParserRuleContext):
super().copyFrom(ctx)
[docs]
class BitwiseXorExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def CARET(self):
return self.getToken(qasm3Parser.CARET, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterBitwiseXorExpression"):
listener.enterBitwiseXorExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitBitwiseXorExpression"):
listener.exitBitwiseXorExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBitwiseXorExpression"):
return visitor.visitBitwiseXorExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class AdditiveExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def PLUS(self):
return self.getToken(qasm3Parser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(qasm3Parser.MINUS, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterAdditiveExpression"):
listener.enterAdditiveExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitAdditiveExpression"):
listener.exitAdditiveExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAdditiveExpression"):
return visitor.visitAdditiveExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class DurationofExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def DURATIONOF(self):
return self.getToken(qasm3Parser.DURATIONOF, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(qasm3Parser.ScopeContext, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDurationofExpression"):
listener.enterDurationofExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDurationofExpression"):
listener.exitDurationofExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDurationofExpression"):
return visitor.visitDurationofExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class ParenthesisExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterParenthesisExpression"):
listener.enterParenthesisExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitParenthesisExpression"):
listener.exitParenthesisExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitParenthesisExpression"):
return visitor.visitParenthesisExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class ComparisonExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def ComparisonOperator(self):
return self.getToken(qasm3Parser.ComparisonOperator, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterComparisonExpression"):
listener.enterComparisonExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitComparisonExpression"):
listener.exitComparisonExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitComparisonExpression"):
return visitor.visitComparisonExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class MultiplicativeExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def ASTERISK(self):
return self.getToken(qasm3Parser.ASTERISK, 0)
[docs]
def SLASH(self):
return self.getToken(qasm3Parser.SLASH, 0)
[docs]
def PERCENT(self):
return self.getToken(qasm3Parser.PERCENT, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterMultiplicativeExpression"):
listener.enterMultiplicativeExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitMultiplicativeExpression"):
listener.exitMultiplicativeExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMultiplicativeExpression"):
return visitor.visitMultiplicativeExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class LogicalOrExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def DOUBLE_PIPE(self):
return self.getToken(qasm3Parser.DOUBLE_PIPE, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterLogicalOrExpression"):
listener.enterLogicalOrExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitLogicalOrExpression"):
listener.exitLogicalOrExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitLogicalOrExpression"):
return visitor.visitLogicalOrExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class CastExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def arrayType(self):
return self.getTypedRuleContext(qasm3Parser.ArrayTypeContext, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterCastExpression"):
listener.enterCastExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitCastExpression"):
listener.exitCastExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitCastExpression"):
return visitor.visitCastExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class PowerExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def DOUBLE_ASTERISK(self):
return self.getToken(qasm3Parser.DOUBLE_ASTERISK, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterPowerExpression"):
listener.enterPowerExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitPowerExpression"):
listener.exitPowerExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitPowerExpression"):
return visitor.visitPowerExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class BitwiseOrExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def PIPE(self):
return self.getToken(qasm3Parser.PIPE, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterBitwiseOrExpression"):
listener.enterBitwiseOrExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitBitwiseOrExpression"):
listener.exitBitwiseOrExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBitwiseOrExpression"):
return visitor.visitBitwiseOrExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class CallExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionListContext, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterCallExpression"):
listener.enterCallExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitCallExpression"):
listener.exitCallExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitCallExpression"):
return visitor.visitCallExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class BitshiftExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def BitshiftOperator(self):
return self.getToken(qasm3Parser.BitshiftOperator, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterBitshiftExpression"):
listener.enterBitshiftExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitBitshiftExpression"):
listener.exitBitshiftExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBitshiftExpression"):
return visitor.visitBitshiftExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class BitwiseAndExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def AMPERSAND(self):
return self.getToken(qasm3Parser.AMPERSAND, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterBitwiseAndExpression"):
listener.enterBitwiseAndExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitBitwiseAndExpression"):
listener.exitBitwiseAndExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBitwiseAndExpression"):
return visitor.visitBitwiseAndExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class EqualityExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def EqualityOperator(self):
return self.getToken(qasm3Parser.EqualityOperator, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterEqualityExpression"):
listener.enterEqualityExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitEqualityExpression"):
listener.exitEqualityExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitEqualityExpression"):
return visitor.visitEqualityExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class LogicalAndExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def DOUBLE_AMPERSAND(self):
return self.getToken(qasm3Parser.DOUBLE_AMPERSAND, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterLogicalAndExpression"):
listener.enterLogicalAndExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitLogicalAndExpression"):
listener.exitLogicalAndExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitLogicalAndExpression"):
return visitor.visitLogicalAndExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class IndexExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def indexOperator(self):
return self.getTypedRuleContext(qasm3Parser.IndexOperatorContext, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterIndexExpression"):
listener.enterIndexExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitIndexExpression"):
listener.exitIndexExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIndexExpression"):
return visitor.visitIndexExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class UnaryExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def TILDE(self):
return self.getToken(qasm3Parser.TILDE, 0)
[docs]
def EXCLAMATION_POINT(self):
return self.getToken(qasm3Parser.EXCLAMATION_POINT, 0)
[docs]
def MINUS(self):
return self.getToken(qasm3Parser.MINUS, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterUnaryExpression"):
listener.enterUnaryExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitUnaryExpression"):
listener.exitUnaryExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitUnaryExpression"):
return visitor.visitUnaryExpression(self)
else:
return visitor.visitChildren(self)
[docs]
class LiteralExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a qasm3Parser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def BinaryIntegerLiteral(self):
return self.getToken(qasm3Parser.BinaryIntegerLiteral, 0)
[docs]
def OctalIntegerLiteral(self):
return self.getToken(qasm3Parser.OctalIntegerLiteral, 0)
[docs]
def DecimalIntegerLiteral(self):
return self.getToken(qasm3Parser.DecimalIntegerLiteral, 0)
[docs]
def HexIntegerLiteral(self):
return self.getToken(qasm3Parser.HexIntegerLiteral, 0)
[docs]
def FloatLiteral(self):
return self.getToken(qasm3Parser.FloatLiteral, 0)
[docs]
def ImaginaryLiteral(self):
return self.getToken(qasm3Parser.ImaginaryLiteral, 0)
[docs]
def BooleanLiteral(self):
return self.getToken(qasm3Parser.BooleanLiteral, 0)
[docs]
def BitstringLiteral(self):
return self.getToken(qasm3Parser.BitstringLiteral, 0)
[docs]
def TimingLiteral(self):
return self.getToken(qasm3Parser.TimingLiteral, 0)
[docs]
def HardwareQubit(self):
return self.getToken(qasm3Parser.HardwareQubit, 0)
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterLiteralExpression"):
listener.enterLiteralExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitLiteralExpression"):
listener.exitLiteralExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitLiteralExpression"):
return visitor.visitLiteralExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def expression(self, _p: int = 0):
_parentctx = self._ctx
_parentState = self.state
localctx = qasm3Parser.ExpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 68
self.enterRecursionRule(localctx, 68, self.RULE_expression, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 458
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 42, self._ctx)
if la_ == 1:
localctx = qasm3Parser.ParenthesisExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 432
self.match(qasm3Parser.LPAREN)
self.state = 433
self.expression(0)
self.state = 434
self.match(qasm3Parser.RPAREN)
pass
elif la_ == 2:
localctx = qasm3Parser.UnaryExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 436
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (((_la - 64) & ~0x3F) == 0 and ((1 << (_la - 64)) & 6145) != 0):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 437
self.expression(15)
pass
elif la_ == 3:
localctx = qasm3Parser.CastExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 440
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [28, 29, 30, 31, 32, 33, 34, 36, 37]:
self.state = 438
self.scalarType()
pass
elif token in [35]:
self.state = 439
self.arrayType()
pass
else:
raise NoViableAltException(self)
self.state = 442
self.match(qasm3Parser.LPAREN)
self.state = 443
self.expression(0)
self.state = 444
self.match(qasm3Parser.RPAREN)
pass
elif la_ == 4:
localctx = qasm3Parser.DurationofExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 446
self.match(qasm3Parser.DURATIONOF)
self.state = 447
self.match(qasm3Parser.LPAREN)
self.state = 448
self.scope()
self.state = 449
self.match(qasm3Parser.RPAREN)
pass
elif la_ == 5:
localctx = qasm3Parser.CallExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 451
self.match(qasm3Parser.Identifier)
self.state = 452
self.match(qasm3Parser.LPAREN)
self.state = 454
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 28) & ~0x3F) == 0 and ((1 << (_la - 28)) & -17592117255666689) != 0:
self.state = 453
self.expressionList()
self.state = 456
self.match(qasm3Parser.RPAREN)
pass
elif la_ == 6:
localctx = qasm3Parser.LiteralExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 457
_la = self._input.LA(1)
if not (((_la - 49) & ~0x3F) == 0 and ((1 << (_la - 49)) & 8787503087617) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 497
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 44, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 495
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 43, self._ctx)
if la_ == 1:
localctx = qasm3Parser.PowerExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 460
if not self.precpred(self._ctx, 16):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
self.state = 461
localctx.op = self.match(qasm3Parser.DOUBLE_ASTERISK)
self.state = 462
self.expression(16)
pass
elif la_ == 2:
localctx = qasm3Parser.MultiplicativeExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 463
if not self.precpred(self._ctx, 14):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
self.state = 464
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (((_la - 65) & ~0x3F) == 0 and ((1 << (_la - 65)) & 13) != 0):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 465
self.expression(15)
pass
elif la_ == 3:
localctx = qasm3Parser.AdditiveExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 466
if not self.precpred(self._ctx, 13):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
self.state = 467
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (_la == 62 or _la == 64):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 468
self.expression(14)
pass
elif la_ == 4:
localctx = qasm3Parser.BitshiftExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 469
if not self.precpred(self._ctx, 12):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
self.state = 470
localctx.op = self.match(qasm3Parser.BitshiftOperator)
self.state = 471
self.expression(13)
pass
elif la_ == 5:
localctx = qasm3Parser.ComparisonExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 472
if not self.precpred(self._ctx, 11):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
self.state = 473
localctx.op = self.match(qasm3Parser.ComparisonOperator)
self.state = 474
self.expression(12)
pass
elif la_ == 6:
localctx = qasm3Parser.EqualityExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 475
if not self.precpred(self._ctx, 10):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
self.state = 476
localctx.op = self.match(qasm3Parser.EqualityOperator)
self.state = 477
self.expression(11)
pass
elif la_ == 7:
localctx = qasm3Parser.BitwiseAndExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 478
if not self.precpred(self._ctx, 9):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
self.state = 479
localctx.op = self.match(qasm3Parser.AMPERSAND)
self.state = 480
self.expression(10)
pass
elif la_ == 8:
localctx = qasm3Parser.BitwiseXorExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 481
if not self.precpred(self._ctx, 8):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
self.state = 482
localctx.op = self.match(qasm3Parser.CARET)
self.state = 483
self.expression(9)
pass
elif la_ == 9:
localctx = qasm3Parser.BitwiseOrExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 484
if not self.precpred(self._ctx, 7):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
self.state = 485
localctx.op = self.match(qasm3Parser.PIPE)
self.state = 486
self.expression(8)
pass
elif la_ == 10:
localctx = qasm3Parser.LogicalAndExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 487
if not self.precpred(self._ctx, 6):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
self.state = 488
localctx.op = self.match(qasm3Parser.DOUBLE_AMPERSAND)
self.state = 489
self.expression(7)
pass
elif la_ == 11:
localctx = qasm3Parser.LogicalOrExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 490
if not self.precpred(self._ctx, 5):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
self.state = 491
localctx.op = self.match(qasm3Parser.DOUBLE_PIPE)
self.state = 492
self.expression(6)
pass
elif la_ == 12:
localctx = qasm3Parser.IndexExpressionContext(
self, qasm3Parser.ExpressionContext(self, _parentctx, _parentState)
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 493
if not self.precpred(self._ctx, 17):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
self.state = 494
self.indexOperator()
pass
self.state = 499
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 44, self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AliasExpressionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def DOUBLE_PLUS(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.DOUBLE_PLUS)
else:
return self.getToken(qasm3Parser.DOUBLE_PLUS, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_aliasExpression
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterAliasExpression"):
listener.enterAliasExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitAliasExpression"):
listener.exitAliasExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAliasExpression"):
return visitor.visitAliasExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def aliasExpression(self):
localctx = qasm3Parser.AliasExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 70, self.RULE_aliasExpression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 500
self.expression(0)
self.state = 505
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 63:
self.state = 501
self.match(qasm3Parser.DOUBLE_PLUS)
self.state = 502
self.expression(0)
self.state = 507
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DeclarationExpressionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def arrayLiteral(self):
return self.getTypedRuleContext(qasm3Parser.ArrayLiteralContext, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def measureExpression(self):
return self.getTypedRuleContext(qasm3Parser.MeasureExpressionContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_declarationExpression
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDeclarationExpression"):
listener.enterDeclarationExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDeclarationExpression"):
listener.exitDeclarationExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDeclarationExpression"):
return visitor.visitDeclarationExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def declarationExpression(self):
localctx = qasm3Parser.DeclarationExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 72, self.RULE_declarationExpression)
try:
self.state = 511
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [52]:
self.enterOuterAlt(localctx, 1)
self.state = 508
self.arrayLiteral()
pass
elif token in [
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
44,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.enterOuterAlt(localctx, 2)
self.state = 509
self.expression(0)
pass
elif token in [47]:
self.enterOuterAlt(localctx, 3)
self.state = 510
self.measureExpression()
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
[docs]
class MeasureExpressionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def MEASURE(self):
return self.getToken(qasm3Parser.MEASURE, 0)
[docs]
def gateOperand(self):
return self.getTypedRuleContext(qasm3Parser.GateOperandContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_measureExpression
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterMeasureExpression"):
listener.enterMeasureExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitMeasureExpression"):
listener.exitMeasureExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMeasureExpression"):
return visitor.visitMeasureExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def measureExpression(self):
localctx = qasm3Parser.MeasureExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 74, self.RULE_measureExpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 513
self.match(qasm3Parser.MEASURE)
self.state = 514
self.gateOperand()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class RangeExpressionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COLON(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COLON)
else:
return self.getToken(qasm3Parser.COLON, i)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_rangeExpression
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterRangeExpression"):
listener.enterRangeExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitRangeExpression"):
listener.exitRangeExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitRangeExpression"):
return visitor.visitRangeExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def rangeExpression(self):
localctx = qasm3Parser.RangeExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 76, self.RULE_rangeExpression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 517
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 28) & ~0x3F) == 0 and ((1 << (_la - 28)) & -17592117255666689) != 0:
self.state = 516
self.expression(0)
self.state = 519
self.match(qasm3Parser.COLON)
self.state = 521
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 28) & ~0x3F) == 0 and ((1 << (_la - 28)) & -17592117255666689) != 0:
self.state = 520
self.expression(0)
self.state = 525
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 56:
self.state = 523
self.match(qasm3Parser.COLON)
self.state = 524
self.expression(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SetExpressionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LBRACE(self):
return self.getToken(qasm3Parser.LBRACE, 0)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def RBRACE(self):
return self.getToken(qasm3Parser.RBRACE, 0)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_setExpression
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterSetExpression"):
listener.enterSetExpression(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitSetExpression"):
listener.exitSetExpression(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitSetExpression"):
return visitor.visitSetExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def setExpression(self):
localctx = qasm3Parser.SetExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 78, self.RULE_setExpression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 527
self.match(qasm3Parser.LBRACE)
self.state = 528
self.expression(0)
self.state = 533
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 50, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 529
self.match(qasm3Parser.COMMA)
self.state = 530
self.expression(0)
self.state = 535
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 50, self._ctx)
self.state = 537
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 536
self.match(qasm3Parser.COMMA)
self.state = 539
self.match(qasm3Parser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayLiteralContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LBRACE(self):
return self.getToken(qasm3Parser.LBRACE, 0)
[docs]
def RBRACE(self):
return self.getToken(qasm3Parser.RBRACE, 0)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def arrayLiteral(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ArrayLiteralContext)
else:
return self.getTypedRuleContext(qasm3Parser.ArrayLiteralContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_arrayLiteral
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterArrayLiteral"):
listener.enterArrayLiteral(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitArrayLiteral"):
listener.exitArrayLiteral(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArrayLiteral"):
return visitor.visitArrayLiteral(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayLiteral(self):
localctx = qasm3Parser.ArrayLiteralContext(self, self._ctx, self.state)
self.enterRule(localctx, 80, self.RULE_arrayLiteral)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 541
self.match(qasm3Parser.LBRACE)
self.state = 544
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
44,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.state = 542
self.expression(0)
pass
elif token in [52]:
self.state = 543
self.arrayLiteral()
pass
else:
raise NoViableAltException(self)
self.state = 553
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 54, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 546
self.match(qasm3Parser.COMMA)
self.state = 549
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
44,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.state = 547
self.expression(0)
pass
elif token in [52]:
self.state = 548
self.arrayLiteral()
pass
else:
raise NoViableAltException(self)
self.state = 555
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 54, self._ctx)
self.state = 557
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 556
self.match(qasm3Parser.COMMA)
self.state = 559
self.match(qasm3Parser.RBRACE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IndexOperatorContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LBRACKET(self):
return self.getToken(qasm3Parser.LBRACKET, 0)
[docs]
def RBRACKET(self):
return self.getToken(qasm3Parser.RBRACKET, 0)
[docs]
def setExpression(self):
return self.getTypedRuleContext(qasm3Parser.SetExpressionContext, 0)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def rangeExpression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.RangeExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.RangeExpressionContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_indexOperator
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterIndexOperator"):
listener.enterIndexOperator(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitIndexOperator"):
listener.exitIndexOperator(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIndexOperator"):
return visitor.visitIndexOperator(self)
else:
return visitor.visitChildren(self)
[docs]
def indexOperator(self):
localctx = qasm3Parser.IndexOperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 82, self.RULE_indexOperator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 561
self.match(qasm3Parser.LBRACKET)
self.state = 580
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [52]:
self.state = 562
self.setExpression()
pass
elif token in [
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
44,
49,
54,
56,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.state = 565
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 56, self._ctx)
if la_ == 1:
self.state = 563
self.expression(0)
pass
elif la_ == 2:
self.state = 564
self.rangeExpression()
pass
self.state = 574
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 58, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 567
self.match(qasm3Parser.COMMA)
self.state = 570
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 57, self._ctx)
if la_ == 1:
self.state = 568
self.expression(0)
pass
elif la_ == 2:
self.state = 569
self.rangeExpression()
pass
self.state = 576
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 58, self._ctx)
self.state = 578
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 577
self.match(qasm3Parser.COMMA)
pass
else:
raise NoViableAltException(self)
self.state = 582
self.match(qasm3Parser.RBRACKET)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IndexedIdentifierContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def indexOperator(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.IndexOperatorContext)
else:
return self.getTypedRuleContext(qasm3Parser.IndexOperatorContext, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_indexedIdentifier
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterIndexedIdentifier"):
listener.enterIndexedIdentifier(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitIndexedIdentifier"):
listener.exitIndexedIdentifier(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIndexedIdentifier"):
return visitor.visitIndexedIdentifier(self)
else:
return visitor.visitChildren(self)
[docs]
def indexedIdentifier(self):
localctx = qasm3Parser.IndexedIdentifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 84, self.RULE_indexedIdentifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 584
self.match(qasm3Parser.Identifier)
self.state = 588
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 50:
self.state = 585
self.indexOperator()
self.state = 590
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ReturnSignatureContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ARROW(self):
return self.getToken(qasm3Parser.ARROW, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_returnSignature
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterReturnSignature"):
listener.enterReturnSignature(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitReturnSignature"):
listener.exitReturnSignature(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitReturnSignature"):
return visitor.visitReturnSignature(self)
else:
return visitor.visitChildren(self)
[docs]
def returnSignature(self):
localctx = qasm3Parser.ReturnSignatureContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_returnSignature)
try:
self.enterOuterAlt(localctx, 1)
self.state = 591
self.match(qasm3Parser.ARROW)
self.state = 592
self.scalarType()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class GateModifierContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def AT(self):
return self.getToken(qasm3Parser.AT, 0)
[docs]
def INV(self):
return self.getToken(qasm3Parser.INV, 0)
[docs]
def POW(self):
return self.getToken(qasm3Parser.POW, 0)
[docs]
def LPAREN(self):
return self.getToken(qasm3Parser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(qasm3Parser.RPAREN, 0)
[docs]
def CTRL(self):
return self.getToken(qasm3Parser.CTRL, 0)
[docs]
def NEGCTRL(self):
return self.getToken(qasm3Parser.NEGCTRL, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_gateModifier
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterGateModifier"):
listener.enterGateModifier(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitGateModifier"):
listener.exitGateModifier(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateModifier"):
return visitor.visitGateModifier(self)
else:
return visitor.visitChildren(self)
[docs]
def gateModifier(self):
localctx = qasm3Parser.GateModifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 88, self.RULE_gateModifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 607
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [39]:
self.state = 594
self.match(qasm3Parser.INV)
pass
elif token in [40]:
self.state = 595
self.match(qasm3Parser.POW)
self.state = 596
self.match(qasm3Parser.LPAREN)
self.state = 597
self.expression(0)
self.state = 598
self.match(qasm3Parser.RPAREN)
pass
elif token in [41, 42]:
self.state = 600
_la = self._input.LA(1)
if not (_la == 41 or _la == 42):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 605
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 54:
self.state = 601
self.match(qasm3Parser.LPAREN)
self.state = 602
self.expression(0)
self.state = 603
self.match(qasm3Parser.RPAREN)
pass
else:
raise NoViableAltException(self)
self.state = 609
self.match(qasm3Parser.AT)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ScalarTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BIT(self):
return self.getToken(qasm3Parser.BIT, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def INT(self):
return self.getToken(qasm3Parser.INT, 0)
[docs]
def UINT(self):
return self.getToken(qasm3Parser.UINT, 0)
[docs]
def FLOAT(self):
return self.getToken(qasm3Parser.FLOAT, 0)
[docs]
def ANGLE(self):
return self.getToken(qasm3Parser.ANGLE, 0)
[docs]
def BOOL(self):
return self.getToken(qasm3Parser.BOOL, 0)
[docs]
def DURATION(self):
return self.getToken(qasm3Parser.DURATION, 0)
[docs]
def STRETCH(self):
return self.getToken(qasm3Parser.STRETCH, 0)
[docs]
def COMPLEX(self):
return self.getToken(qasm3Parser.COMPLEX, 0)
[docs]
def LBRACKET(self):
return self.getToken(qasm3Parser.LBRACKET, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(qasm3Parser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_scalarType
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterScalarType"):
listener.enterScalarType(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitScalarType"):
listener.exitScalarType(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitScalarType"):
return visitor.visitScalarType(self)
else:
return visitor.visitChildren(self)
[docs]
def scalarType(self):
localctx = qasm3Parser.ScalarTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 90, self.RULE_scalarType)
self._la = 0 # Token type
try:
self.state = 641
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [29]:
self.enterOuterAlt(localctx, 1)
self.state = 611
self.match(qasm3Parser.BIT)
self.state = 613
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 612
self.designator()
pass
elif token in [30]:
self.enterOuterAlt(localctx, 2)
self.state = 615
self.match(qasm3Parser.INT)
self.state = 617
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 616
self.designator()
pass
elif token in [31]:
self.enterOuterAlt(localctx, 3)
self.state = 619
self.match(qasm3Parser.UINT)
self.state = 621
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 620
self.designator()
pass
elif token in [32]:
self.enterOuterAlt(localctx, 4)
self.state = 623
self.match(qasm3Parser.FLOAT)
self.state = 625
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 624
self.designator()
pass
elif token in [33]:
self.enterOuterAlt(localctx, 5)
self.state = 627
self.match(qasm3Parser.ANGLE)
self.state = 629
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 628
self.designator()
pass
elif token in [28]:
self.enterOuterAlt(localctx, 6)
self.state = 631
self.match(qasm3Parser.BOOL)
pass
elif token in [36]:
self.enterOuterAlt(localctx, 7)
self.state = 632
self.match(qasm3Parser.DURATION)
pass
elif token in [37]:
self.enterOuterAlt(localctx, 8)
self.state = 633
self.match(qasm3Parser.STRETCH)
pass
elif token in [34]:
self.enterOuterAlt(localctx, 9)
self.state = 634
self.match(qasm3Parser.COMPLEX)
self.state = 639
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 635
self.match(qasm3Parser.LBRACKET)
self.state = 636
self.scalarType()
self.state = 637
self.match(qasm3Parser.RBRACKET)
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
[docs]
class QubitTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def QUBIT(self):
return self.getToken(qasm3Parser.QUBIT, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_qubitType
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterQubitType"):
listener.enterQubitType(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitQubitType"):
listener.exitQubitType(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitQubitType"):
return visitor.visitQubitType(self)
else:
return visitor.visitChildren(self)
[docs]
def qubitType(self):
localctx = qasm3Parser.QubitTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 92, self.RULE_qubitType)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 643
self.match(qasm3Parser.QUBIT)
self.state = 645
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 644
self.designator()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ARRAY(self):
return self.getToken(qasm3Parser.ARRAY, 0)
[docs]
def LBRACKET(self):
return self.getToken(qasm3Parser.LBRACKET, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def COMMA(self):
return self.getToken(qasm3Parser.COMMA, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionListContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(qasm3Parser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_arrayType
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterArrayType"):
listener.enterArrayType(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitArrayType"):
listener.exitArrayType(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArrayType"):
return visitor.visitArrayType(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayType(self):
localctx = qasm3Parser.ArrayTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 94, self.RULE_arrayType)
try:
self.enterOuterAlt(localctx, 1)
self.state = 647
self.match(qasm3Parser.ARRAY)
self.state = 648
self.match(qasm3Parser.LBRACKET)
self.state = 649
self.scalarType()
self.state = 650
self.match(qasm3Parser.COMMA)
self.state = 651
self.expressionList()
self.state = 652
self.match(qasm3Parser.RBRACKET)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArrayReferenceTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ARRAY(self):
return self.getToken(qasm3Parser.ARRAY, 0)
[docs]
def LBRACKET(self):
return self.getToken(qasm3Parser.LBRACKET, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def COMMA(self):
return self.getToken(qasm3Parser.COMMA, 0)
[docs]
def RBRACKET(self):
return self.getToken(qasm3Parser.RBRACKET, 0)
[docs]
def CONST(self):
return self.getToken(qasm3Parser.CONST, 0)
[docs]
def MUTABLE(self):
return self.getToken(qasm3Parser.MUTABLE, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionListContext, 0)
[docs]
def DIM(self):
return self.getToken(qasm3Parser.DIM, 0)
[docs]
def EQUALS(self):
return self.getToken(qasm3Parser.EQUALS, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_arrayReferenceType
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterArrayReferenceType"):
listener.enterArrayReferenceType(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitArrayReferenceType"):
listener.exitArrayReferenceType(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArrayReferenceType"):
return visitor.visitArrayReferenceType(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayReferenceType(self):
localctx = qasm3Parser.ArrayReferenceTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 96, self.RULE_arrayReferenceType)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 654
_la = self._input.LA(1)
if not (_la == 23 or _la == 24):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 655
self.match(qasm3Parser.ARRAY)
self.state = 656
self.match(qasm3Parser.LBRACKET)
self.state = 657
self.scalarType()
self.state = 658
self.match(qasm3Parser.COMMA)
self.state = 663
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
44,
49,
54,
64,
75,
76,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
]:
self.state = 659
self.expressionList()
pass
elif token in [43]:
self.state = 660
self.match(qasm3Parser.DIM)
self.state = 661
self.match(qasm3Parser.EQUALS)
self.state = 662
self.expression(0)
pass
else:
raise NoViableAltException(self)
self.state = 665
self.match(qasm3Parser.RBRACKET)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DesignatorContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LBRACKET(self):
return self.getToken(qasm3Parser.LBRACKET, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(qasm3Parser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_designator
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDesignator"):
listener.enterDesignator(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDesignator"):
listener.exitDesignator(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDesignator"):
return visitor.visitDesignator(self)
else:
return visitor.visitChildren(self)
[docs]
def designator(self):
localctx = qasm3Parser.DesignatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_designator)
try:
self.enterOuterAlt(localctx, 1)
self.state = 667
self.match(qasm3Parser.LBRACKET)
self.state = 668
self.expression(0)
self.state = 669
self.match(qasm3Parser.RBRACKET)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class GateOperandContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def indexedIdentifier(self):
return self.getTypedRuleContext(qasm3Parser.IndexedIdentifierContext, 0)
[docs]
def HardwareQubit(self):
return self.getToken(qasm3Parser.HardwareQubit, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_gateOperand
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterGateOperand"):
listener.enterGateOperand(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitGateOperand"):
listener.exitGateOperand(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateOperand"):
return visitor.visitGateOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def gateOperand(self):
localctx = qasm3Parser.GateOperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_gateOperand)
try:
self.state = 673
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [87]:
self.enterOuterAlt(localctx, 1)
self.state = 671
self.indexedIdentifier()
pass
elif token in [88]:
self.enterOuterAlt(localctx, 2)
self.state = 672
self.match(qasm3Parser.HardwareQubit)
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
[docs]
class ExternArgumentContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def arrayReferenceType(self):
return self.getTypedRuleContext(qasm3Parser.ArrayReferenceTypeContext, 0)
[docs]
def CREG(self):
return self.getToken(qasm3Parser.CREG, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_externArgument
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterExternArgument"):
listener.enterExternArgument(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitExternArgument"):
listener.exitExternArgument(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExternArgument"):
return visitor.visitExternArgument(self)
else:
return visitor.visitChildren(self)
[docs]
def externArgument(self):
localctx = qasm3Parser.ExternArgumentContext(self, self._ctx, self.state)
self.enterRule(localctx, 102, self.RULE_externArgument)
self._la = 0 # Token type
try:
self.state = 681
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [28, 29, 30, 31, 32, 33, 34, 36, 37]:
self.enterOuterAlt(localctx, 1)
self.state = 675
self.scalarType()
pass
elif token in [23, 24]:
self.enterOuterAlt(localctx, 2)
self.state = 676
self.arrayReferenceType()
pass
elif token in [27]:
self.enterOuterAlt(localctx, 3)
self.state = 677
self.match(qasm3Parser.CREG)
self.state = 679
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 678
self.designator()
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
[docs]
class DefcalArgumentContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def HardwareQubit(self):
return self.getToken(qasm3Parser.HardwareQubit, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_defcalArgument
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDefcalArgument"):
listener.enterDefcalArgument(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDefcalArgument"):
listener.exitDefcalArgument(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefcalArgument"):
return visitor.visitDefcalArgument(self)
else:
return visitor.visitChildren(self)
[docs]
def defcalArgument(self):
localctx = qasm3Parser.DefcalArgumentContext(self, self._ctx, self.state)
self.enterRule(localctx, 104, self.RULE_defcalArgument)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 683
_la = self._input.LA(1)
if not (_la == 87 or _la == 88):
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
[docs]
class ArgumentDefinitionContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def scalarType(self):
return self.getTypedRuleContext(qasm3Parser.ScalarTypeContext, 0)
[docs]
def Identifier(self):
return self.getToken(qasm3Parser.Identifier, 0)
[docs]
def qubitType(self):
return self.getTypedRuleContext(qasm3Parser.QubitTypeContext, 0)
[docs]
def CREG(self):
return self.getToken(qasm3Parser.CREG, 0)
[docs]
def QREG(self):
return self.getToken(qasm3Parser.QREG, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(qasm3Parser.DesignatorContext, 0)
[docs]
def arrayReferenceType(self):
return self.getTypedRuleContext(qasm3Parser.ArrayReferenceTypeContext, 0)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_argumentDefinition
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterArgumentDefinition"):
listener.enterArgumentDefinition(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitArgumentDefinition"):
listener.exitArgumentDefinition(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArgumentDefinition"):
return visitor.visitArgumentDefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def argumentDefinition(self):
localctx = qasm3Parser.ArgumentDefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_argumentDefinition)
self._la = 0 # Token type
try:
self.state = 699
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [28, 29, 30, 31, 32, 33, 34, 36, 37]:
self.enterOuterAlt(localctx, 1)
self.state = 685
self.scalarType()
self.state = 686
self.match(qasm3Parser.Identifier)
pass
elif token in [26]:
self.enterOuterAlt(localctx, 2)
self.state = 688
self.qubitType()
self.state = 689
self.match(qasm3Parser.Identifier)
pass
elif token in [25, 27]:
self.enterOuterAlt(localctx, 3)
self.state = 691
_la = self._input.LA(1)
if not (_la == 25 or _la == 27):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 692
self.match(qasm3Parser.Identifier)
self.state = 694
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 50:
self.state = 693
self.designator()
pass
elif token in [23, 24]:
self.enterOuterAlt(localctx, 4)
self.state = 696
self.arrayReferenceType()
self.state = 697
self.match(qasm3Parser.Identifier)
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
[docs]
class ArgumentDefinitionListContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def argumentDefinition(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ArgumentDefinitionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ArgumentDefinitionContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_argumentDefinitionList
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterArgumentDefinitionList"):
listener.enterArgumentDefinitionList(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitArgumentDefinitionList"):
listener.exitArgumentDefinitionList(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArgumentDefinitionList"):
return visitor.visitArgumentDefinitionList(self)
else:
return visitor.visitChildren(self)
[docs]
def argumentDefinitionList(self):
localctx = qasm3Parser.ArgumentDefinitionListContext(self, self._ctx, self.state)
self.enterRule(localctx, 108, self.RULE_argumentDefinitionList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 701
self.argumentDefinition()
self.state = 706
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 78, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 702
self.match(qasm3Parser.COMMA)
self.state = 703
self.argumentDefinition()
self.state = 708
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 78, self._ctx)
self.state = 710
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 709
self.match(qasm3Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExpressionListContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExpressionContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExpressionContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_expressionList
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterExpressionList"):
listener.enterExpressionList(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitExpressionList"):
listener.exitExpressionList(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExpressionList"):
return visitor.visitExpressionList(self)
else:
return visitor.visitChildren(self)
[docs]
def expressionList(self):
localctx = qasm3Parser.ExpressionListContext(self, self._ctx, self.state)
self.enterRule(localctx, 110, self.RULE_expressionList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 712
self.expression(0)
self.state = 717
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 80, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 713
self.match(qasm3Parser.COMMA)
self.state = 714
self.expression(0)
self.state = 719
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 80, self._ctx)
self.state = 721
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 720
self.match(qasm3Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DefcalArgumentListContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def defcalArgument(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.DefcalArgumentContext)
else:
return self.getTypedRuleContext(qasm3Parser.DefcalArgumentContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_defcalArgumentList
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterDefcalArgumentList"):
listener.enterDefcalArgumentList(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitDefcalArgumentList"):
listener.exitDefcalArgumentList(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefcalArgumentList"):
return visitor.visitDefcalArgumentList(self)
else:
return visitor.visitChildren(self)
[docs]
def defcalArgumentList(self):
localctx = qasm3Parser.DefcalArgumentListContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_defcalArgumentList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 723
self.defcalArgument()
self.state = 728
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 82, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 724
self.match(qasm3Parser.COMMA)
self.state = 725
self.defcalArgument()
self.state = 730
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 82, self._ctx)
self.state = 732
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 731
self.match(qasm3Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IdentifierListContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def Identifier(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.Identifier)
else:
return self.getToken(qasm3Parser.Identifier, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_identifierList
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterIdentifierList"):
listener.enterIdentifierList(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitIdentifierList"):
listener.exitIdentifierList(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIdentifierList"):
return visitor.visitIdentifierList(self)
else:
return visitor.visitChildren(self)
[docs]
def identifierList(self):
localctx = qasm3Parser.IdentifierListContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_identifierList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 734
self.match(qasm3Parser.Identifier)
self.state = 739
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 84, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 735
self.match(qasm3Parser.COMMA)
self.state = 736
self.match(qasm3Parser.Identifier)
self.state = 741
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 84, self._ctx)
self.state = 743
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 742
self.match(qasm3Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class GateOperandListContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def gateOperand(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.GateOperandContext)
else:
return self.getTypedRuleContext(qasm3Parser.GateOperandContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_gateOperandList
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterGateOperandList"):
listener.enterGateOperandList(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitGateOperandList"):
listener.exitGateOperandList(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateOperandList"):
return visitor.visitGateOperandList(self)
else:
return visitor.visitChildren(self)
[docs]
def gateOperandList(self):
localctx = qasm3Parser.GateOperandListContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_gateOperandList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 745
self.gateOperand()
self.state = 750
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 86, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 746
self.match(qasm3Parser.COMMA)
self.state = 747
self.gateOperand()
self.state = 752
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 86, self._ctx)
self.state = 754
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 753
self.match(qasm3Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExternArgumentListContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def externArgument(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(qasm3Parser.ExternArgumentContext)
else:
return self.getTypedRuleContext(qasm3Parser.ExternArgumentContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(qasm3Parser.COMMA)
else:
return self.getToken(qasm3Parser.COMMA, i)
[docs]
def getRuleIndex(self):
return qasm3Parser.RULE_externArgumentList
[docs]
def enterRule(self, listener: ParseTreeListener):
if hasattr(listener, "enterExternArgumentList"):
listener.enterExternArgumentList(self)
[docs]
def exitRule(self, listener: ParseTreeListener):
if hasattr(listener, "exitExternArgumentList"):
listener.exitExternArgumentList(self)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExternArgumentList"):
return visitor.visitExternArgumentList(self)
else:
return visitor.visitChildren(self)
[docs]
def externArgumentList(self):
localctx = qasm3Parser.ExternArgumentListContext(self, self._ctx, self.state)
self.enterRule(localctx, 118, self.RULE_externArgumentList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 756
self.externArgument()
self.state = 761
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 88, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 757
self.match(qasm3Parser.COMMA)
self.state = 758
self.externArgument()
self.state = 763
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 88, self._ctx)
self.state = 765
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 59:
self.state = 764
self.match(qasm3Parser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int):
if self._predicates == None:
self._predicates = dict()
self._predicates[34] = self.expression_sempred
pred = self._predicates.get(ruleIndex, None)
if pred is None:
raise Exception("No predicate with index:" + str(ruleIndex))
else:
return pred(localctx, predIndex)
[docs]
def expression_sempred(self, localctx: ExpressionContext, predIndex: int):
if predIndex == 0:
return self.precpred(self._ctx, 16)
if predIndex == 1:
return self.precpred(self._ctx, 14)
if predIndex == 2:
return self.precpred(self._ctx, 13)
if predIndex == 3:
return self.precpred(self._ctx, 12)
if predIndex == 4:
return self.precpred(self._ctx, 11)
if predIndex == 5:
return self.precpred(self._ctx, 10)
if predIndex == 6:
return self.precpred(self._ctx, 9)
if predIndex == 7:
return self.precpred(self._ctx, 8)
if predIndex == 8:
return self.precpred(self._ctx, 7)
if predIndex == 9:
return self.precpred(self._ctx, 6)
if predIndex == 10:
return self.precpred(self._ctx, 5)
if predIndex == 11:
return self.precpred(self._ctx, 17)