# Generated from BraketPragmasParser.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,
130,
992,
2,
0,
7,
0,
2,
1,
7,
1,
2,
2,
7,
2,
2,
3,
7,
3,
2,
4,
7,
4,
2,
5,
7,
5,
2,
6,
7,
6,
2,
7,
7,
7,
2,
8,
7,
8,
2,
9,
7,
9,
2,
10,
7,
10,
2,
11,
7,
11,
2,
12,
7,
12,
2,
13,
7,
13,
2,
14,
7,
14,
2,
15,
7,
15,
2,
16,
7,
16,
2,
17,
7,
17,
2,
18,
7,
18,
2,
19,
7,
19,
2,
20,
7,
20,
2,
21,
7,
21,
2,
22,
7,
22,
2,
23,
7,
23,
2,
24,
7,
24,
2,
25,
7,
25,
2,
26,
7,
26,
2,
27,
7,
27,
2,
28,
7,
28,
2,
29,
7,
29,
2,
30,
7,
30,
2,
31,
7,
31,
2,
32,
7,
32,
2,
33,
7,
33,
2,
34,
7,
34,
2,
35,
7,
35,
2,
36,
7,
36,
2,
37,
7,
37,
2,
38,
7,
38,
2,
39,
7,
39,
2,
40,
7,
40,
2,
41,
7,
41,
2,
42,
7,
42,
2,
43,
7,
43,
2,
44,
7,
44,
2,
45,
7,
45,
2,
46,
7,
46,
2,
47,
7,
47,
2,
48,
7,
48,
2,
49,
7,
49,
2,
50,
7,
50,
2,
51,
7,
51,
2,
52,
7,
52,
2,
53,
7,
53,
2,
54,
7,
54,
2,
55,
7,
55,
2,
56,
7,
56,
2,
57,
7,
57,
2,
58,
7,
58,
2,
59,
7,
59,
2,
60,
7,
60,
2,
61,
7,
61,
2,
62,
7,
62,
2,
63,
7,
63,
2,
64,
7,
64,
2,
65,
7,
65,
2,
66,
7,
66,
2,
67,
7,
67,
2,
68,
7,
68,
2,
69,
7,
69,
2,
70,
7,
70,
2,
71,
7,
71,
2,
72,
7,
72,
2,
73,
7,
73,
2,
74,
7,
74,
2,
75,
7,
75,
2,
76,
7,
76,
2,
77,
7,
77,
2,
78,
7,
78,
2,
79,
7,
79,
2,
80,
7,
80,
2,
81,
7,
81,
2,
82,
7,
82,
2,
83,
7,
83,
2,
84,
7,
84,
2,
85,
7,
85,
2,
86,
7,
86,
2,
87,
7,
87,
1,
0,
1,
0,
1,
0,
1,
0,
3,
0,
181,
8,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
1,
2,
1,
2,
1,
3,
1,
3,
1,
3,
1,
3,
5,
3,
197,
8,
3,
10,
3,
12,
3,
200,
9,
3,
1,
3,
1,
3,
1,
4,
1,
4,
1,
4,
1,
4,
5,
4,
208,
8,
4,
10,
4,
12,
4,
211,
9,
4,
1,
4,
1,
4,
1,
5,
1,
5,
1,
5,
1,
5,
1,
6,
1,
6,
1,
6,
1,
6,
3,
6,
223,
8,
6,
1,
7,
1,
7,
1,
8,
1,
8,
1,
9,
1,
9,
3,
9,
231,
8,
9,
1,
10,
1,
10,
1,
11,
1,
11,
1,
11,
5,
11,
238,
8,
11,
10,
11,
12,
11,
241,
9,
11,
1,
11,
3,
11,
244,
8,
11,
1,
12,
1,
12,
1,
12,
1,
13,
1,
13,
1,
14,
1,
14,
1,
14,
5,
14,
254,
8,
14,
10,
14,
12,
14,
257,
9,
14,
1,
15,
1,
15,
1,
15,
1,
16,
1,
16,
1,
16,
3,
16,
265,
8,
16,
1,
17,
1,
17,
1,
17,
1,
17,
1,
17,
1,
17,
1,
17,
1,
17,
3,
17,
275,
8,
17,
1,
18,
1,
18,
3,
18,
279,
8,
18,
1,
18,
1,
18,
1,
18,
1,
19,
1,
19,
1,
19,
1,
19,
1,
19,
1,
19,
1,
20,
1,
20,
1,
21,
1,
21,
1,
22,
3,
22,
295,
8,
22,
1,
22,
1,
22,
3,
22,
299,
8,
22,
1,
22,
1,
22,
1,
22,
3,
22,
304,
8,
22,
1,
22,
3,
22,
307,
8,
22,
1,
23,
1,
23,
1,
23,
1,
23,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
1,
24,
3,
24,
325,
8,
24,
1,
25,
1,
25,
1,
25,
5,
25,
330,
8,
25,
10,
25,
12,
25,
333,
9,
25,
1,
26,
1,
26,
1,
26,
5,
26,
338,
8,
26,
10,
26,
12,
26,
341,
9,
26,
1,
27,
1,
27,
1,
28,
3,
28,
346,
8,
28,
1,
28,
5,
28,
349,
8,
28,
10,
28,
12,
28,
352,
9,
28,
1,
28,
1,
28,
1,
29,
1,
29,
1,
29,
1,
29,
1,
30,
1,
30,
5,
30,
362,
8,
30,
10,
30,
12,
30,
365,
9,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
1,
30,
3,
30,
394,
8,
30,
3,
30,
396,
8,
30,
1,
31,
1,
31,
3,
31,
400,
8,
31,
1,
32,
1,
32,
5,
32,
404,
8,
32,
10,
32,
12,
32,
407,
9,
32,
1,
32,
1,
32,
1,
33,
1,
33,
1,
33,
1,
34,
1,
34,
3,
34,
416,
8,
34,
1,
35,
1,
35,
1,
35,
1,
35,
1,
36,
1,
36,
1,
36,
1,
36,
1,
37,
1,
37,
1,
37,
1,
38,
1,
38,
1,
38,
1,
39,
1,
39,
1,
39,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
1,
40,
3,
40,
445,
8,
40,
1,
40,
1,
40,
1,
41,
1,
41,
1,
41,
1,
41,
1,
41,
1,
41,
1,
41,
3,
41,
456,
8,
41,
1,
42,
1,
42,
1,
42,
3,
42,
461,
8,
42,
1,
42,
1,
42,
1,
43,
1,
43,
1,
43,
1,
43,
1,
43,
1,
43,
1,
44,
1,
44,
3,
44,
473,
8,
44,
1,
44,
1,
44,
1,
45,
1,
45,
3,
45,
479,
8,
45,
1,
45,
1,
45,
1,
46,
1,
46,
1,
46,
3,
46,
486,
8,
46,
1,
46,
1,
46,
1,
47,
5,
47,
491,
8,
47,
10,
47,
12,
47,
494,
9,
47,
1,
47,
1,
47,
1,
47,
3,
47,
499,
8,
47,
1,
47,
3,
47,
502,
8,
47,
1,
47,
3,
47,
505,
8,
47,
1,
47,
1,
47,
1,
47,
1,
47,
5,
47,
511,
8,
47,
10,
47,
12,
47,
514,
9,
47,
1,
47,
1,
47,
1,
47,
3,
47,
519,
8,
47,
1,
47,
3,
47,
522,
8,
47,
1,
47,
3,
47,
525,
8,
47,
1,
47,
3,
47,
528,
8,
47,
1,
47,
3,
47,
531,
8,
47,
1,
48,
1,
48,
1,
48,
3,
48,
536,
8,
48,
1,
48,
1,
48,
1,
49,
1,
49,
1,
49,
1,
49,
1,
50,
1,
50,
1,
50,
1,
50,
1,
50,
1,
50,
1,
51,
1,
51,
3,
51,
552,
8,
51,
1,
51,
1,
51,
1,
51,
3,
51,
557,
8,
51,
1,
51,
1,
51,
1,
52,
1,
52,
1,
52,
1,
52,
1,
52,
1,
52,
1,
52,
1,
53,
1,
53,
1,
53,
3,
53,
571,
8,
53,
1,
53,
1,
53,
1,
53,
1,
54,
1,
54,
1,
54,
3,
54,
579,
8,
54,
1,
54,
1,
54,
1,
55,
1,
55,
1,
55,
1,
55,
1,
56,
1,
56,
1,
56,
1,
56,
3,
56,
591,
8,
56,
1,
56,
1,
56,
3,
56,
595,
8,
56,
1,
56,
1,
56,
1,
57,
1,
57,
1,
57,
1,
57,
3,
57,
603,
8,
57,
1,
57,
1,
57,
3,
57,
607,
8,
57,
1,
57,
1,
57,
1,
58,
1,
58,
1,
58,
1,
58,
3,
58,
615,
8,
58,
1,
58,
3,
58,
618,
8,
58,
1,
58,
1,
58,
1,
58,
1,
59,
1,
59,
1,
59,
1,
59,
3,
59,
627,
8,
59,
1,
59,
1,
59,
1,
60,
1,
60,
1,
60,
1,
61,
1,
61,
1,
61,
1,
61,
3,
61,
638,
8,
61,
1,
61,
3,
61,
641,
8,
61,
1,
61,
1,
61,
3,
61,
645,
8,
61,
1,
61,
1,
61,
5,
61,
649,
8,
61,
10,
61,
12,
61,
652,
9,
61,
1,
61,
1,
61,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
3,
62,
665,
8,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
3,
62,
679,
8,
62,
1,
62,
1,
62,
3,
62,
683,
8,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
1,
62,
5,
62,
720,
8,
62,
10,
62,
12,
62,
723,
9,
62,
1,
63,
1,
63,
1,
63,
5,
63,
728,
8,
63,
10,
63,
12,
63,
731,
9,
63,
1,
64,
1,
64,
1,
64,
3,
64,
736,
8,
64,
1,
65,
1,
65,
1,
65,
1,
66,
3,
66,
742,
8,
66,
1,
66,
1,
66,
3,
66,
746,
8,
66,
1,
66,
1,
66,
3,
66,
750,
8,
66,
1,
67,
1,
67,
1,
67,
1,
67,
5,
67,
756,
8,
67,
10,
67,
12,
67,
759,
9,
67,
1,
67,
3,
67,
762,
8,
67,
1,
67,
1,
67,
1,
68,
1,
68,
1,
68,
3,
68,
769,
8,
68,
1,
68,
1,
68,
1,
68,
3,
68,
774,
8,
68,
5,
68,
776,
8,
68,
10,
68,
12,
68,
779,
9,
68,
1,
68,
3,
68,
782,
8,
68,
1,
68,
1,
68,
1,
69,
1,
69,
1,
69,
1,
69,
3,
69,
790,
8,
69,
1,
69,
1,
69,
1,
69,
3,
69,
795,
8,
69,
5,
69,
797,
8,
69,
10,
69,
12,
69,
800,
9,
69,
1,
69,
3,
69,
803,
8,
69,
3,
69,
805,
8,
69,
1,
69,
1,
69,
1,
70,
1,
70,
5,
70,
811,
8,
70,
10,
70,
12,
70,
814,
9,
70,
1,
71,
1,
71,
1,
71,
1,
72,
1,
72,
1,
72,
1,
72,
1,
72,
1,
72,
1,
72,
1,
72,
1,
72,
1,
72,
1,
72,
3,
72,
830,
8,
72,
3,
72,
832,
8,
72,
1,
72,
1,
72,
1,
73,
1,
73,
3,
73,
838,
8,
73,
1,
73,
1,
73,
3,
73,
842,
8,
73,
1,
73,
1,
73,
3,
73,
846,
8,
73,
1,
73,
1,
73,
3,
73,
850,
8,
73,
1,
73,
1,
73,
3,
73,
854,
8,
73,
1,
73,
1,
73,
1,
73,
1,
73,
1,
73,
1,
73,
1,
73,
1,
73,
3,
73,
864,
8,
73,
3,
73,
866,
8,
73,
1,
74,
1,
74,
3,
74,
870,
8,
74,
1,
75,
1,
75,
1,
75,
1,
75,
1,
75,
1,
75,
1,
75,
1,
76,
1,
76,
1,
76,
1,
76,
1,
76,
1,
76,
1,
76,
1,
76,
1,
76,
3,
76,
888,
8,
76,
1,
76,
1,
76,
1,
77,
1,
77,
1,
77,
1,
77,
1,
78,
1,
78,
3,
78,
898,
8,
78,
1,
79,
1,
79,
1,
79,
1,
79,
3,
79,
904,
8,
79,
3,
79,
906,
8,
79,
1,
80,
1,
80,
1,
81,
1,
81,
1,
81,
1,
81,
1,
81,
1,
81,
1,
81,
1,
81,
1,
81,
3,
81,
919,
8,
81,
1,
81,
1,
81,
1,
81,
3,
81,
924,
8,
81,
1,
82,
1,
82,
1,
82,
5,
82,
929,
8,
82,
10,
82,
12,
82,
932,
9,
82,
1,
82,
3,
82,
935,
8,
82,
1,
83,
1,
83,
1,
83,
5,
83,
940,
8,
83,
10,
83,
12,
83,
943,
9,
83,
1,
83,
3,
83,
946,
8,
83,
1,
84,
1,
84,
1,
84,
5,
84,
951,
8,
84,
10,
84,
12,
84,
954,
9,
84,
1,
84,
3,
84,
957,
8,
84,
1,
85,
1,
85,
1,
85,
5,
85,
962,
8,
85,
10,
85,
12,
85,
965,
9,
85,
1,
85,
3,
85,
968,
8,
85,
1,
86,
1,
86,
1,
86,
5,
86,
973,
8,
86,
10,
86,
12,
86,
976,
9,
86,
1,
86,
3,
86,
979,
8,
86,
1,
87,
1,
87,
1,
87,
5,
87,
984,
8,
87,
10,
87,
12,
87,
987,
9,
87,
1,
87,
3,
87,
990,
8,
87,
1,
87,
1,
650,
1,
124,
88,
0,
2,
4,
6,
8,
10,
12,
14,
16,
18,
20,
22,
24,
26,
28,
30,
32,
34,
36,
38,
40,
42,
44,
46,
48,
50,
52,
54,
56,
58,
60,
62,
64,
66,
68,
70,
72,
74,
76,
78,
80,
82,
84,
86,
88,
90,
92,
94,
96,
98,
100,
102,
104,
106,
108,
110,
112,
114,
116,
118,
120,
122,
124,
126,
128,
130,
132,
134,
136,
138,
140,
142,
144,
146,
148,
150,
152,
154,
156,
158,
160,
162,
164,
166,
168,
170,
172,
174,
0,
16,
1,
0,
7,
8,
1,
0,
10,
12,
1,
0,
13,
17,
3,
0,
111,
111,
114,
114,
118,
118,
2,
0,
114,
114,
118,
118,
2,
0,
92,
92,
94,
94,
1,
0,
21,
29,
1,
0,
51,
52,
2,
0,
55,
55,
57,
57,
2,
0,
90,
90,
107,
107,
2,
0,
94,
94,
104,
105,
2,
0,
79,
79,
111,
120,
2,
0,
95,
95,
97,
98,
1,
0,
71,
72,
1,
0,
53,
54,
1,
0,
116,
117,
1069,
0,
180,
1,
0,
0,
0,
2,
182,
1,
0,
0,
0,
4,
189,
1,
0,
0,
0,
6,
192,
1,
0,
0,
0,
8,
203,
1,
0,
0,
0,
10,
214,
1,
0,
0,
0,
12,
222,
1,
0,
0,
0,
14,
224,
1,
0,
0,
0,
16,
226,
1,
0,
0,
0,
18,
228,
1,
0,
0,
0,
20,
232,
1,
0,
0,
0,
22,
243,
1,
0,
0,
0,
24,
245,
1,
0,
0,
0,
26,
248,
1,
0,
0,
0,
28,
250,
1,
0,
0,
0,
30,
258,
1,
0,
0,
0,
32,
264,
1,
0,
0,
0,
34,
274,
1,
0,
0,
0,
36,
278,
1,
0,
0,
0,
38,
283,
1,
0,
0,
0,
40,
289,
1,
0,
0,
0,
42,
291,
1,
0,
0,
0,
44,
306,
1,
0,
0,
0,
46,
308,
1,
0,
0,
0,
48,
324,
1,
0,
0,
0,
50,
326,
1,
0,
0,
0,
52,
334,
1,
0,
0,
0,
54,
342,
1,
0,
0,
0,
56,
345,
1,
0,
0,
0,
58,
355,
1,
0,
0,
0,
60,
395,
1,
0,
0,
0,
62,
397,
1,
0,
0,
0,
64,
401,
1,
0,
0,
0,
66,
410,
1,
0,
0,
0,
68,
415,
1,
0,
0,
0,
70,
417,
1,
0,
0,
0,
72,
421,
1,
0,
0,
0,
74,
425,
1,
0,
0,
0,
76,
428,
1,
0,
0,
0,
78,
431,
1,
0,
0,
0,
80,
434,
1,
0,
0,
0,
82,
448,
1,
0,
0,
0,
84,
457,
1,
0,
0,
0,
86,
464,
1,
0,
0,
0,
88,
470,
1,
0,
0,
0,
90,
476,
1,
0,
0,
0,
92,
482,
1,
0,
0,
0,
94,
530,
1,
0,
0,
0,
96,
532,
1,
0,
0,
0,
98,
539,
1,
0,
0,
0,
100,
543,
1,
0,
0,
0,
102,
551,
1,
0,
0,
0,
104,
560,
1,
0,
0,
0,
106,
567,
1,
0,
0,
0,
108,
575,
1,
0,
0,
0,
110,
582,
1,
0,
0,
0,
112,
586,
1,
0,
0,
0,
114,
598,
1,
0,
0,
0,
116,
610,
1,
0,
0,
0,
118,
622,
1,
0,
0,
0,
120,
630,
1,
0,
0,
0,
122,
633,
1,
0,
0,
0,
124,
682,
1,
0,
0,
0,
126,
724,
1,
0,
0,
0,
128,
735,
1,
0,
0,
0,
130,
737,
1,
0,
0,
0,
132,
741,
1,
0,
0,
0,
134,
751,
1,
0,
0,
0,
136,
765,
1,
0,
0,
0,
138,
785,
1,
0,
0,
0,
140,
808,
1,
0,
0,
0,
142,
815,
1,
0,
0,
0,
144,
831,
1,
0,
0,
0,
146,
865,
1,
0,
0,
0,
148,
867,
1,
0,
0,
0,
150,
871,
1,
0,
0,
0,
152,
878,
1,
0,
0,
0,
154,
891,
1,
0,
0,
0,
156,
897,
1,
0,
0,
0,
158,
905,
1,
0,
0,
0,
160,
907,
1,
0,
0,
0,
162,
923,
1,
0,
0,
0,
164,
925,
1,
0,
0,
0,
166,
936,
1,
0,
0,
0,
168,
947,
1,
0,
0,
0,
170,
958,
1,
0,
0,
0,
172,
969,
1,
0,
0,
0,
174,
980,
1,
0,
0,
0,
176,
181,
3,
10,
5,
0,
177,
181,
3,
2,
1,
0,
178,
181,
3,
46,
23,
0,
179,
181,
3,
4,
2,
0,
180,
176,
1,
0,
0,
0,
180,
177,
1,
0,
0,
0,
180,
178,
1,
0,
0,
0,
180,
179,
1,
0,
0,
0,
181,
1,
1,
0,
0,
0,
182,
183,
5,
1,
0,
0,
183,
184,
5,
2,
0,
0,
184,
185,
5,
84,
0,
0,
185,
186,
3,
6,
3,
0,
186,
187,
5,
85,
0,
0,
187,
188,
3,
22,
11,
0,
188,
3,
1,
0,
0,
0,
189,
190,
5,
1,
0,
0,
190,
191,
5,
5,
0,
0,
191,
5,
1,
0,
0,
0,
192,
193,
5,
80,
0,
0,
193,
198,
3,
8,
4,
0,
194,
195,
5,
89,
0,
0,
195,
197,
3,
8,
4,
0,
196,
194,
1,
0,
0,
0,
197,
200,
1,
0,
0,
0,
198,
196,
1,
0,
0,
0,
198,
199,
1,
0,
0,
0,
199,
201,
1,
0,
0,
0,
200,
198,
1,
0,
0,
0,
201,
202,
5,
81,
0,
0,
202,
7,
1,
0,
0,
0,
203,
204,
5,
80,
0,
0,
204,
209,
3,
44,
22,
0,
205,
206,
5,
89,
0,
0,
206,
208,
3,
44,
22,
0,
207,
205,
1,
0,
0,
0,
208,
211,
1,
0,
0,
0,
209,
207,
1,
0,
0,
0,
209,
210,
1,
0,
0,
0,
210,
212,
1,
0,
0,
0,
211,
209,
1,
0,
0,
0,
212,
213,
5,
81,
0,
0,
213,
9,
1,
0,
0,
0,
214,
215,
5,
1,
0,
0,
215,
216,
5,
3,
0,
0,
216,
217,
3,
12,
6,
0,
217,
11,
1,
0,
0,
0,
218,
223,
3,
14,
7,
0,
219,
223,
3,
18,
9,
0,
220,
223,
3,
24,
12,
0,
221,
223,
3,
30,
15,
0,
222,
218,
1,
0,
0,
0,
222,
219,
1,
0,
0,
0,
222,
220,
1,
0,
0,
0,
222,
221,
1,
0,
0,
0,
223,
13,
1,
0,
0,
0,
224,
225,
3,
16,
8,
0,
225,
15,
1,
0,
0,
0,
226,
227,
5,
6,
0,
0,
227,
17,
1,
0,
0,
0,
228,
230,
3,
20,
10,
0,
229,
231,
3,
22,
11,
0,
230,
229,
1,
0,
0,
0,
230,
231,
1,
0,
0,
0,
231,
19,
1,
0,
0,
0,
232,
233,
7,
0,
0,
0,
233,
21,
1,
0,
0,
0,
234,
239,
3,
156,
78,
0,
235,
236,
5,
89,
0,
0,
236,
238,
3,
156,
78,
0,
237,
235,
1,
0,
0,
0,
238,
241,
1,
0,
0,
0,
239,
237,
1,
0,
0,
0,
239,
240,
1,
0,
0,
0,
240,
244,
1,
0,
0,
0,
241,
239,
1,
0,
0,
0,
242,
244,
5,
19,
0,
0,
243,
234,
1,
0,
0,
0,
243,
242,
1,
0,
0,
0,
244,
23,
1,
0,
0,
0,
245,
246,
3,
26,
13,
0,
246,
247,
3,
28,
14,
0,
247,
25,
1,
0,
0,
0,
248,
249,
5,
9,
0,
0,
249,
27,
1,
0,
0,
0,
250,
255,
5,
120,
0,
0,
251,
252,
5,
89,
0,
0,
252,
254,
5,
120,
0,
0,
253,
251,
1,
0,
0,
0,
254,
257,
1,
0,
0,
0,
255,
253,
1,
0,
0,
0,
255,
256,
1,
0,
0,
0,
256,
29,
1,
0,
0,
0,
257,
255,
1,
0,
0,
0,
258,
259,
3,
40,
20,
0,
259,
260,
3,
32,
16,
0,
260,
31,
1,
0,
0,
0,
261,
265,
3,
34,
17,
0,
262,
265,
3,
36,
18,
0,
263,
265,
3,
38,
19,
0,
264,
261,
1,
0,
0,
0,
264,
262,
1,
0,
0,
0,
264,
263,
1,
0,
0,
0,
265,
33,
1,
0,
0,
0,
266,
267,
3,
42,
21,
0,
267,
268,
5,
84,
0,
0,
268,
269,
3,
156,
78,
0,
269,
270,
5,
85,
0,
0,
270,
275,
1,
0,
0,
0,
271,
272,
3,
42,
21,
0,
272,
273,
5,
19,
0,
0,
273,
275,
1,
0,
0,
0,
274,
266,
1,
0,
0,
0,
274,
271,
1,
0,
0,
0,
275,
35,
1,
0,
0,
0,
276,
279,
3,
34,
17,
0,
277,
279,
3,
38,
19,
0,
278,
276,
1,
0,
0,
0,
278,
277,
1,
0,
0,
0,
279,
280,
1,
0,
0,
0,
280,
281,
5,
20,
0,
0,
281,
282,
3,
32,
16,
0,
282,
37,
1,
0,
0,
0,
283,
284,
5,
18,
0,
0,
284,
285,
5,
84,
0,
0,
285,
286,
3,
6,
3,
0,
286,
287,
5,
85,
0,
0,
287,
288,
3,
22,
11,
0,
288,
39,
1,
0,
0,
0,
289,
290,
7,
1,
0,
0,
290,
41,
1,
0,
0,
0,
291,
292,
7,
2,
0,
0,
292,
43,
1,
0,
0,
0,
293,
295,
5,
94,
0,
0,
294,
293,
1,
0,
0,
0,
294,
295,
1,
0,
0,
0,
295,
296,
1,
0,
0,
0,
296,
307,
7,
3,
0,
0,
297,
299,
5,
94,
0,
0,
298,
297,
1,
0,
0,
0,
298,
299,
1,
0,
0,
0,
299,
300,
1,
0,
0,
0,
300,
301,
7,
4,
0,
0,
301,
303,
7,
5,
0,
0,
302,
304,
5,
94,
0,
0,
303,
302,
1,
0,
0,
0,
303,
304,
1,
0,
0,
0,
304,
305,
1,
0,
0,
0,
305,
307,
5,
111,
0,
0,
306,
294,
1,
0,
0,
0,
306,
298,
1,
0,
0,
0,
307,
45,
1,
0,
0,
0,
308,
309,
5,
1,
0,
0,
309,
310,
5,
4,
0,
0,
310,
311,
3,
48,
24,
0,
311,
47,
1,
0,
0,
0,
312,
313,
3,
54,
27,
0,
313,
314,
5,
84,
0,
0,
314,
315,
3,
52,
26,
0,
315,
316,
5,
85,
0,
0,
316,
317,
3,
22,
11,
0,
317,
325,
1,
0,
0,
0,
318,
319,
5,
30,
0,
0,
319,
320,
5,
84,
0,
0,
320,
321,
3,
50,
25,
0,
321,
322,
5,
85,
0,
0,
322,
323,
3,
22,
11,
0,
323,
325,
1,
0,
0,
0,
324,
312,
1,
0,
0,
0,
324,
318,
1,
0,
0,
0,
325,
49,
1,
0,
0,
0,
326,
331,
3,
6,
3,
0,
327,
328,
5,
89,
0,
0,
328,
330,
3,
6,
3,
0,
329,
327,
1,
0,
0,
0,
330,
333,
1,
0,
0,
0,
331,
329,
1,
0,
0,
0,
331,
332,
1,
0,
0,
0,
332,
51,
1,
0,
0,
0,
333,
331,
1,
0,
0,
0,
334,
339,
5,
118,
0,
0,
335,
336,
5,
89,
0,
0,
336,
338,
5,
118,
0,
0,
337,
335,
1,
0,
0,
0,
338,
341,
1,
0,
0,
0,
339,
337,
1,
0,
0,
0,
339,
340,
1,
0,
0,
0,
340,
53,
1,
0,
0,
0,
341,
339,
1,
0,
0,
0,
342,
343,
7,
6,
0,
0,
343,
55,
1,
0,
0,
0,
344,
346,
3,
58,
29,
0,
345,
344,
1,
0,
0,
0,
345,
346,
1,
0,
0,
0,
346,
350,
1,
0,
0,
0,
347,
349,
3,
60,
30,
0,
348,
347,
1,
0,
0,
0,
349,
352,
1,
0,
0,
0,
350,
348,
1,
0,
0,
0,
350,
351,
1,
0,
0,
0,
351,
353,
1,
0,
0,
0,
352,
350,
1,
0,
0,
0,
353,
354,
5,
0,
0,
1,
354,
57,
1,
0,
0,
0,
355,
356,
5,
31,
0,
0,
356,
357,
5,
127,
0,
0,
357,
358,
5,
87,
0,
0,
358,
59,
1,
0,
0,
0,
359,
396,
3,
66,
33,
0,
360,
362,
3,
62,
31,
0,
361,
360,
1,
0,
0,
0,
362,
365,
1,
0,
0,
0,
363,
361,
1,
0,
0,
0,
363,
364,
1,
0,
0,
0,
364,
393,
1,
0,
0,
0,
365,
363,
1,
0,
0,
0,
366,
394,
3,
100,
50,
0,
367,
394,
3,
118,
59,
0,
368,
394,
3,
88,
44,
0,
369,
394,
3,
90,
45,
0,
370,
394,
3,
74,
37,
0,
371,
394,
3,
70,
35,
0,
372,
394,
3,
102,
51,
0,
373,
394,
3,
104,
52,
0,
374,
394,
3,
76,
38,
0,
375,
394,
3,
112,
56,
0,
376,
394,
3,
122,
61,
0,
377,
394,
3,
92,
46,
0,
378,
394,
3,
78,
39,
0,
379,
394,
3,
120,
60,
0,
380,
394,
3,
114,
57,
0,
381,
394,
3,
80,
40,
0,
382,
394,
3,
94,
47,
0,
383,
394,
3,
116,
58,
0,
384,
394,
3,
82,
41,
0,
385,
394,
3,
72,
36,
0,
386,
394,
3,
106,
53,
0,
387,
394,
3,
96,
48,
0,
388,
394,
3,
108,
54,
0,
389,
394,
3,
110,
55,
0,
390,
394,
3,
98,
49,
0,
391,
394,
3,
84,
42,
0,
392,
394,
3,
86,
43,
0,
393,
366,
1,
0,
0,
0,
393,
367,
1,
0,
0,
0,
393,
368,
1,
0,
0,
0,
393,
369,
1,
0,
0,
0,
393,
370,
1,
0,
0,
0,
393,
371,
1,
0,
0,
0,
393,
372,
1,
0,
0,
0,
393,
373,
1,
0,
0,
0,
393,
374,
1,
0,
0,
0,
393,
375,
1,
0,
0,
0,
393,
376,
1,
0,
0,
0,
393,
377,
1,
0,
0,
0,
393,
378,
1,
0,
0,
0,
393,
379,
1,
0,
0,
0,
393,
380,
1,
0,
0,
0,
393,
381,
1,
0,
0,
0,
393,
382,
1,
0,
0,
0,
393,
383,
1,
0,
0,
0,
393,
384,
1,
0,
0,
0,
393,
385,
1,
0,
0,
0,
393,
386,
1,
0,
0,
0,
393,
387,
1,
0,
0,
0,
393,
388,
1,
0,
0,
0,
393,
389,
1,
0,
0,
0,
393,
390,
1,
0,
0,
0,
393,
391,
1,
0,
0,
0,
393,
392,
1,
0,
0,
0,
394,
396,
1,
0,
0,
0,
395,
359,
1,
0,
0,
0,
395,
363,
1,
0,
0,
0,
396,
61,
1,
0,
0,
0,
397,
399,
5,
50,
0,
0,
398,
400,
5,
130,
0,
0,
399,
398,
1,
0,
0,
0,
399,
400,
1,
0,
0,
0,
400,
63,
1,
0,
0,
0,
401,
405,
5,
82,
0,
0,
402,
404,
3,
60,
30,
0,
403,
402,
1,
0,
0,
0,
404,
407,
1,
0,
0,
0,
405,
403,
1,
0,
0,
0,
405,
406,
1,
0,
0,
0,
406,
408,
1,
0,
0,
0,
407,
405,
1,
0,
0,
0,
408,
409,
5,
83,
0,
0,
409,
65,
1,
0,
0,
0,
410,
411,
5,
49,
0,
0,
411,
412,
5,
130,
0,
0,
412,
67,
1,
0,
0,
0,
413,
416,
3,
60,
30,
0,
414,
416,
3,
64,
32,
0,
415,
413,
1,
0,
0,
0,
415,
414,
1,
0,
0,
0,
416,
69,
1,
0,
0,
0,
417,
418,
5,
33,
0,
0,
418,
419,
5,
121,
0,
0,
419,
420,
5,
87,
0,
0,
420,
71,
1,
0,
0,
0,
421,
422,
5,
32,
0,
0,
422,
423,
5,
121,
0,
0,
423,
424,
5,
87,
0,
0,
424,
73,
1,
0,
0,
0,
425,
426,
5,
40,
0,
0,
426,
427,
5,
87,
0,
0,
427,
75,
1,
0,
0,
0,
428,
429,
5,
41,
0,
0,
429,
430,
5,
87,
0,
0,
430,
77,
1,
0,
0,
0,
431,
432,
5,
44,
0,
0,
432,
433,
5,
87,
0,
0,
433,
79,
1,
0,
0,
0,
434,
435,
5,
46,
0,
0,
435,
436,
3,
146,
73,
0,
436,
437,
5,
116,
0,
0,
437,
444,
5,
48,
0,
0,
438,
445,
3,
134,
67,
0,
439,
440,
5,
80,
0,
0,
440,
441,
3,
132,
66,
0,
441,
442,
5,
81,
0,
0,
442,
445,
1,
0,
0,
0,
443,
445,
5,
116,
0,
0,
444,
438,
1,
0,
0,
0,
444,
439,
1,
0,
0,
0,
444,
443,
1,
0,
0,
0,
445,
446,
1,
0,
0,
0,
446,
447,
3,
68,
34,
0,
447,
81,
1,
0,
0,
0,
448,
449,
5,
42,
0,
0,
449,
450,
5,
84,
0,
0,
450,
451,
3,
124,
62,
0,
451,
452,
5,
85,
0,
0,
452,
455,
3,
68,
34,
0,
453,
454,
5,
43,
0,
0,
454,
456,
3,
68,
34,
0,
455,
453,
1,
0,
0,
0,
455,
456,
1,
0,
0,
0,
456,
83,
1,
0,
0,
0,
457,
460,
5,
45,
0,
0,
458,
461,
3,
124,
62,
0,
459,
461,
3,
130,
65,
0,
460,
458,
1,
0,
0,
0,
460,
459,
1,
0,
0,
0,
460,
461,
1,
0,
0,
0,
461,
462,
1,
0,
0,
0,
462,
463,
5,
87,
0,
0,
463,
85,
1,
0,
0,
0,
464,
465,
5,
47,
0,
0,
465,
466,
5,
84,
0,
0,
466,
467,
3,
124,
62,
0,
467,
468,
5,
85,
0,
0,
468,
469,
3,
68,
34,
0,
469,
87,
1,
0,
0,
0,
470,
472,
5,
78,
0,
0,
471,
473,
3,
172,
86,
0,
472,
471,
1,
0,
0,
0,
472,
473,
1,
0,
0,
0,
473,
474,
1,
0,
0,
0,
474,
475,
5,
87,
0,
0,
475,
89,
1,
0,
0,
0,
476,
478,
5,
38,
0,
0,
477,
479,
3,
154,
77,
0,
478,
477,
1,
0,
0,
0,
478,
479,
1,
0,
0,
0,
479,
480,
1,
0,
0,
0,
480,
481,
3,
64,
32,
0,
481,
91,
1,
0,
0,
0,
482,
483,
5,
75,
0,
0,
483,
485,
3,
154,
77,
0,
484,
486,
3,
172,
86,
0,
485,
484,
1,
0,
0,
0,
485,
486,
1,
0,
0,
0,
486,
487,
1,
0,
0,
0,
487,
488,
5,
87,
0,
0,
488,
93,
1,
0,
0,
0,
489,
491,
3,
144,
72,
0,
490,
489,
1,
0,
0,
0,
491,
494,
1,
0,
0,
0,
492,
490,
1,
0,
0,
0,
492,
493,
1,
0,
0,
0,
493,
495,
1,
0,
0,
0,
494,
492,
1,
0,
0,
0,
495,
501,
5,
116,
0,
0,
496,
498,
5,
84,
0,
0,
497,
499,
3,
166,
83,
0,
498,
497,
1,
0,
0,
0,
498,
499,
1,
0,
0,
0,
499,
500,
1,
0,
0,
0,
500,
502,
5,
85,
0,
0,
501,
496,
1,
0,
0,
0,
501,
502,
1,
0,
0,
0,
502,
504,
1,
0,
0,
0,
503,
505,
3,
154,
77,
0,
504,
503,
1,
0,
0,
0,
504,
505,
1,
0,
0,
0,
505,
506,
1,
0,
0,
0,
506,
507,
3,
172,
86,
0,
507,
508,
5,
87,
0,
0,
508,
531,
1,
0,
0,
0,
509,
511,
3,
144,
72,
0,
510,
509,
1,
0,
0,
0,
511,
514,
1,
0,
0,
0,
512,
510,
1,
0,
0,
0,
512,
513,
1,
0,
0,
0,
513,
515,
1,
0,
0,
0,
514,
512,
1,
0,
0,
0,
515,
521,
5,
68,
0,
0,
516,
518,
5,
84,
0,
0,
517,
519,
3,
166,
83,
0,
518,
517,
1,
0,
0,
0,
518,
519,
1,
0,
0,
0,
519,
520,
1,
0,
0,
0,
520,
522,
5,
85,
0,
0,
521,
516,
1,
0,
0,
0,
521,
522,
1,
0,
0,
0,
522,
524,
1,
0,
0,
0,
523,
525,
3,
154,
77,
0,
524,
523,
1,
0,
0,
0,
524,
525,
1,
0,
0,
0,
525,
527,
1,
0,
0,
0,
526,
528,
3,
172,
86,
0,
527,
526,
1,
0,
0,
0,
527,
528,
1,
0,
0,
0,
528,
529,
1,
0,
0,
0,
529,
531,
5,
87,
0,
0,
530,
492,
1,
0,
0,
0,
530,
512,
1,
0,
0,
0,
531,
95,
1,
0,
0,
0,
532,
535,
3,
130,
65,
0,
533,
534,
5,
91,
0,
0,
534,
536,
3,
140,
70,
0,
535,
533,
1,
0,
0,
0,
535,
536,
1,
0,
0,
0,
536,
537,
1,
0,
0,
0,
537,
538,
5,
87,
0,
0,
538,
97,
1,
0,
0,
0,
539,
540,
5,
76,
0,
0,
540,
541,
3,
156,
78,
0,
541,
542,
5,
87,
0,
0,
542,
99,
1,
0,
0,
0,
543,
544,
5,
39,
0,
0,
544,
545,
5,
116,
0,
0,
545,
546,
5,
90,
0,
0,
546,
547,
3,
126,
63,
0,
547,
548,
5,
87,
0,
0,
548,
101,
1,
0,
0,
0,
549,
552,
3,
146,
73,
0,
550,
552,
3,
150,
75,
0,
551,
549,
1,
0,
0,
0,
551,
550,
1,
0,
0,
0,
552,
553,
1,
0,
0,
0,
553,
556,
5,
116,
0,
0,
554,
555,
5,
90,
0,
0,
555,
557,
3,
128,
64,
0,
556,
554,
1,
0,
0,
0,
556,
557,
1,
0,
0,
0,
557,
558,
1,
0,
0,
0,
558,
559,
5,
87,
0,
0,
559,
103,
1,
0,
0,
0,
560,
561,
5,
53,
0,
0,
561,
562,
3,
146,
73,
0,
562,
563,
5,
116,
0,
0,
563,
564,
5,
90,
0,
0,
564,
565,
3,
128,
64,
0,
565,
566,
5,
87,
0,
0,
566,
105,
1,
0,
0,
0,
567,
570,
7,
7,
0,
0,
568,
571,
3,
146,
73,
0,
569,
571,
3,
150,
75,
0,
570,
568,
1,
0,
0,
0,
570,
569,
1,
0,
0,
0,
571,
572,
1,
0,
0,
0,
572,
573,
5,
116,
0,
0,
573,
574,
5,
87,
0,
0,
574,
107,
1,
0,
0,
0,
575,
576,
7,
8,
0,
0,
576,
578,
5,
116,
0,
0,
577,
579,
3,
154,
77,
0,
578,
577,
1,
0,
0,
0,
578,
579,
1,
0,
0,
0,
579,
580,
1,
0,
0,
0,
580,
581,
5,
87,
0,
0,
581,
109,
1,
0,
0,
0,
582,
583,
3,
148,
74,
0,
583,
584,
5,
116,
0,
0,
584,
585,
5,
87,
0,
0,
585,
111,
1,
0,
0,
0,
586,
587,
5,
34,
0,
0,
587,
588,
5,
116,
0,
0,
588,
590,
5,
84,
0,
0,
589,
591,
3,
164,
82,
0,
590,
589,
1,
0,
0,
0,
590,
591,
1,
0,
0,
0,
591,
592,
1,
0,
0,
0,
592,
594,
5,
85,
0,
0,
593,
595,
3,
142,
71,
0,
594,
593,
1,
0,
0,
0,
594,
595,
1,
0,
0,
0,
595,
596,
1,
0,
0,
0,
596,
597,
3,
64,
32,
0,
597,
113,
1,
0,
0,
0,
598,
599,
5,
37,
0,
0,
599,
600,
5,
116,
0,
0,
600,
602,
5,
84,
0,
0,
601,
603,
3,
174,
87,
0,
602,
601,
1,
0,
0,
0,
602,
603,
1,
0,
0,
0,
603,
604,
1,
0,
0,
0,
604,
606,
5,
85,
0,
0,
605,
607,
3,
142,
71,
0,
606,
605,
1,
0,
0,
0,
606,
607,
1,
0,
0,
0,
607,
608,
1,
0,
0,
0,
608,
609,
5,
87,
0,
0,
609,
115,
1,
0,
0,
0,
610,
611,
5,
36,
0,
0,
611,
617,
5,
116,
0,
0,
612,
614,
5,
84,
0,
0,
613,
615,
3,
170,
85,
0,
614,
613,
1,
0,
0,
0,
614,
615,
1,
0,
0,
0,
615,
616,
1,
0,
0,
0,
616,
618,
5,
85,
0,
0,
617,
612,
1,
0,
0,
0,
617,
618,
1,
0,
0,
0,
618,
619,
1,
0,
0,
0,
619,
620,
3,
170,
85,
0,
620,
621,
3,
64,
32,
0,
621,
117,
1,
0,
0,
0,
622,
623,
3,
140,
70,
0,
623,
626,
7,
9,
0,
0,
624,
627,
3,
124,
62,
0,
625,
627,
3,
130,
65,
0,
626,
624,
1,
0,
0,
0,
626,
625,
1,
0,
0,
0,
627,
628,
1,
0,
0,
0,
628,
629,
5,
87,
0,
0,
629,
119,
1,
0,
0,
0,
630,
631,
3,
124,
62,
0,
631,
632,
5,
87,
0,
0,
632,
121,
1,
0,
0,
0,
633,
634,
5,
35,
0,
0,
634,
640,
5,
116,
0,
0,
635,
637,
5,
84,
0,
0,
636,
638,
3,
164,
82,
0,
637,
636,
1,
0,
0,
0,
637,
638,
1,
0,
0,
0,
638,
639,
1,
0,
0,
0,
639,
641,
5,
85,
0,
0,
640,
635,
1,
0,
0,
0,
640,
641,
1,
0,
0,
0,
641,
642,
1,
0,
0,
0,
642,
644,
3,
168,
84,
0,
643,
645,
3,
142,
71,
0,
644,
643,
1,
0,
0,
0,
644,
645,
1,
0,
0,
0,
645,
646,
1,
0,
0,
0,
646,
650,
5,
82,
0,
0,
647,
649,
9,
0,
0,
0,
648,
647,
1,
0,
0,
0,
649,
652,
1,
0,
0,
0,
650,
651,
1,
0,
0,
0,
650,
648,
1,
0,
0,
0,
651,
653,
1,
0,
0,
0,
652,
650,
1,
0,
0,
0,
653,
654,
5,
83,
0,
0,
654,
123,
1,
0,
0,
0,
655,
656,
6,
62,
-1,
0,
656,
657,
5,
84,
0,
0,
657,
658,
3,
124,
62,
0,
658,
659,
5,
85,
0,
0,
659,
683,
1,
0,
0,
0,
660,
661,
7,
10,
0,
0,
661,
683,
3,
124,
62,
15,
662,
665,
3,
146,
73,
0,
663,
665,
3,
150,
75,
0,
664,
662,
1,
0,
0,
0,
664,
663,
1,
0,
0,
0,
665,
666,
1,
0,
0,
0,
666,
667,
5,
84,
0,
0,
667,
668,
3,
124,
62,
0,
668,
669,
5,
85,
0,
0,
669,
683,
1,
0,
0,
0,
670,
671,
5,
74,
0,
0,
671,
672,
5,
84,
0,
0,
672,
673,
3,
64,
32,
0,
673,
674,
5,
85,
0,
0,
674,
683,
1,
0,
0,
0,
675,
676,
5,
116,
0,
0,
676,
678,
5,
84,
0,
0,
677,
679,
3,
166,
83,
0,
678,
677,
1,
0,
0,
0,
678,
679,
1,
0,
0,
0,
679,
680,
1,
0,
0,
0,
680,
683,
5,
85,
0,
0,
681,
683,
7,
11,
0,
0,
682,
655,
1,
0,
0,
0,
682,
660,
1,
0,
0,
0,
682,
664,
1,
0,
0,
0,
682,
670,
1,
0,
0,
0,
682,
675,
1,
0,
0,
0,
682,
681,
1,
0,
0,
0,
683,
721,
1,
0,
0,
0,
684,
685,
10,
16,
0,
0,
685,
686,
5,
96,
0,
0,
686,
720,
3,
124,
62,
16,
687,
688,
10,
14,
0,
0,
688,
689,
7,
12,
0,
0,
689,
720,
3,
124,
62,
15,
690,
691,
10,
13,
0,
0,
691,
692,
7,
5,
0,
0,
692,
720,
3,
124,
62,
14,
693,
694,
10,
12,
0,
0,
694,
695,
5,
109,
0,
0,
695,
720,
3,
124,
62,
13,
696,
697,
10,
11,
0,
0,
697,
698,
5,
108,
0,
0,
698,
720,
3,
124,
62,
12,
699,
700,
10,
10,
0,
0,
700,
701,
5,
106,
0,
0,
701,
720,
3,
124,
62,
11,
702,
703,
10,
9,
0,
0,
703,
704,
5,
101,
0,
0,
704,
720,
3,
124,
62,
10,
705,
706,
10,
8,
0,
0,
706,
707,
5,
103,
0,
0,
707,
720,
3,
124,
62,
9,
708,
709,
10,
7,
0,
0,
709,
710,
5,
99,
0,
0,
710,
720,
3,
124,
62,
8,
711,
712,
10,
6,
0,
0,
712,
713,
5,
102,
0,
0,
713,
720,
3,
124,
62,
7,
714,
715,
10,
5,
0,
0,
715,
716,
5,
100,
0,
0,
716,
720,
3,
124,
62,
6,
717,
718,
10,
17,
0,
0,
718,
720,
3,
138,
69,
0,
719,
684,
1,
0,
0,
0,
719,
687,
1,
0,
0,
0,
719,
690,
1,
0,
0,
0,
719,
693,
1,
0,
0,
0,
719,
696,
1,
0,
0,
0,
719,
699,
1,
0,
0,
0,
719,
702,
1,
0,
0,
0,
719,
705,
1,
0,
0,
0,
719,
708,
1,
0,
0,
0,
719,
711,
1,
0,
0,
0,
719,
714,
1,
0,
0,
0,
719,
717,
1,
0,
0,
0,
720,
723,
1,
0,
0,
0,
721,
719,
1,
0,
0,
0,
721,
722,
1,
0,
0,
0,
722,
125,
1,
0,
0,
0,
723,
721,
1,
0,
0,
0,
724,
729,
3,
124,
62,
0,
725,
726,
5,
93,
0,
0,
726,
728,
3,
124,
62,
0,
727,
725,
1,
0,
0,
0,
728,
731,
1,
0,
0,
0,
729,
727,
1,
0,
0,
0,
729,
730,
1,
0,
0,
0,
730,
127,
1,
0,
0,
0,
731,
729,
1,
0,
0,
0,
732,
736,
3,
136,
68,
0,
733,
736,
3,
124,
62,
0,
734,
736,
3,
130,
65,
0,
735,
732,
1,
0,
0,
0,
735,
733,
1,
0,
0,
0,
735,
734,
1,
0,
0,
0,
736,
129,
1,
0,
0,
0,
737,
738,
5,
77,
0,
0,
738,
739,
3,
156,
78,
0,
739,
131,
1,
0,
0,
0,
740,
742,
3,
124,
62,
0,
741,
740,
1,
0,
0,
0,
741,
742,
1,
0,
0,
0,
742,
743,
1,
0,
0,
0,
743,
745,
5,
86,
0,
0,
744,
746,
3,
124,
62,
0,
745,
744,
1,
0,
0,
0,
745,
746,
1,
0,
0,
0,
746,
749,
1,
0,
0,
0,
747,
748,
5,
86,
0,
0,
748,
750,
3,
124,
62,
0,
749,
747,
1,
0,
0,
0,
749,
750,
1,
0,
0,
0,
750,
133,
1,
0,
0,
0,
751,
752,
5,
82,
0,
0,
752,
757,
3,
124,
62,
0,
753,
754,
5,
89,
0,
0,
754,
756,
3,
124,
62,
0,
755,
753,
1,
0,
0,
0,
756,
759,
1,
0,
0,
0,
757,
755,
1,
0,
0,
0,
757,
758,
1,
0,
0,
0,
758,
761,
1,
0,
0,
0,
759,
757,
1,
0,
0,
0,
760,
762,
5,
89,
0,
0,
761,
760,
1,
0,
0,
0,
761,
762,
1,
0,
0,
0,
762,
763,
1,
0,
0,
0,
763,
764,
5,
83,
0,
0,
764,
135,
1,
0,
0,
0,
765,
768,
5,
82,
0,
0,
766,
769,
3,
124,
62,
0,
767,
769,
3,
136,
68,
0,
768,
766,
1,
0,
0,
0,
768,
767,
1,
0,
0,
0,
769,
777,
1,
0,
0,
0,
770,
773,
5,
89,
0,
0,
771,
774,
3,
124,
62,
0,
772,
774,
3,
136,
68,
0,
773,
771,
1,
0,
0,
0,
773,
772,
1,
0,
0,
0,
774,
776,
1,
0,
0,
0,
775,
770,
1,
0,
0,
0,
776,
779,
1,
0,
0,
0,
777,
775,
1,
0,
0,
0,
777,
778,
1,
0,
0,
0,
778,
781,
1,
0,
0,
0,
779,
777,
1,
0,
0,
0,
780,
782,
5,
89,
0,
0,
781,
780,
1,
0,
0,
0,
781,
782,
1,
0,
0,
0,
782,
783,
1,
0,
0,
0,
783,
784,
5,
83,
0,
0,
784,
137,
1,
0,
0,
0,
785,
804,
5,
80,
0,
0,
786,
805,
3,
134,
67,
0,
787,
790,
3,
124,
62,
0,
788,
790,
3,
132,
66,
0,
789,
787,
1,
0,
0,
0,
789,
788,
1,
0,
0,
0,
790,
798,
1,
0,
0,
0,
791,
794,
5,
89,
0,
0,
792,
795,
3,
124,
62,
0,
793,
795,
3,
132,
66,
0,
794,
792,
1,
0,
0,
0,
794,
793,
1,
0,
0,
0,
795,
797,
1,
0,
0,
0,
796,
791,
1,
0,
0,
0,
797,
800,
1,
0,
0,
0,
798,
796,
1,
0,
0,
0,
798,
799,
1,
0,
0,
0,
799,
802,
1,
0,
0,
0,
800,
798,
1,
0,
0,
0,
801,
803,
5,
89,
0,
0,
802,
801,
1,
0,
0,
0,
802,
803,
1,
0,
0,
0,
803,
805,
1,
0,
0,
0,
804,
786,
1,
0,
0,
0,
804,
789,
1,
0,
0,
0,
805,
806,
1,
0,
0,
0,
806,
807,
5,
81,
0,
0,
807,
139,
1,
0,
0,
0,
808,
812,
5,
116,
0,
0,
809,
811,
3,
138,
69,
0,
810,
809,
1,
0,
0,
0,
811,
814,
1,
0,
0,
0,
812,
810,
1,
0,
0,
0,
812,
813,
1,
0,
0,
0,
813,
141,
1,
0,
0,
0,
814,
812,
1,
0,
0,
0,
815,
816,
5,
91,
0,
0,
816,
817,
3,
146,
73,
0,
817,
143,
1,
0,
0,
0,
818,
832,
5,
69,
0,
0,
819,
820,
5,
70,
0,
0,
820,
821,
5,
84,
0,
0,
821,
822,
3,
124,
62,
0,
822,
823,
5,
85,
0,
0,
823,
832,
1,
0,
0,
0,
824,
829,
7,
13,
0,
0,
825,
826,
5,
84,
0,
0,
826,
827,
3,
124,
62,
0,
827,
828,
5,
85,
0,
0,
828,
830,
1,
0,
0,
0,
829,
825,
1,
0,
0,
0,
829,
830,
1,
0,
0,
0,
830,
832,
1,
0,
0,
0,
831,
818,
1,
0,
0,
0,
831,
819,
1,
0,
0,
0,
831,
824,
1,
0,
0,
0,
832,
833,
1,
0,
0,
0,
833,
834,
5,
20,
0,
0,
834,
145,
1,
0,
0,
0,
835,
837,
5,
59,
0,
0,
836,
838,
3,
154,
77,
0,
837,
836,
1,
0,
0,
0,
837,
838,
1,
0,
0,
0,
838,
866,
1,
0,
0,
0,
839,
841,
5,
60,
0,
0,
840,
842,
3,
154,
77,
0,
841,
840,
1,
0,
0,
0,
841,
842,
1,
0,
0,
0,
842,
866,
1,
0,
0,
0,
843,
845,
5,
61,
0,
0,
844,
846,
3,
154,
77,
0,
845,
844,
1,
0,
0,
0,
845,
846,
1,
0,
0,
0,
846,
866,
1,
0,
0,
0,
847,
849,
5,
62,
0,
0,
848,
850,
3,
154,
77,
0,
849,
848,
1,
0,
0,
0,
849,
850,
1,
0,
0,
0,
850,
866,
1,
0,
0,
0,
851,
853,
5,
63,
0,
0,
852,
854,
3,
154,
77,
0,
853,
852,
1,
0,
0,
0,
853,
854,
1,
0,
0,
0,
854,
866,
1,
0,
0,
0,
855,
866,
5,
58,
0,
0,
856,
866,
5,
66,
0,
0,
857,
866,
5,
67,
0,
0,
858,
863,
5,
64,
0,
0,
859,
860,
5,
80,
0,
0,
860,
861,
3,
146,
73,
0,
861,
862,
5,
81,
0,
0,
862,
864,
1,
0,
0,
0,
863,
859,
1,
0,
0,
0,
863,
864,
1,
0,
0,
0,
864,
866,
1,
0,
0,
0,
865,
835,
1,
0,
0,
0,
865,
839,
1,
0,
0,
0,
865,
843,
1,
0,
0,
0,
865,
847,
1,
0,
0,
0,
865,
851,
1,
0,
0,
0,
865,
855,
1,
0,
0,
0,
865,
856,
1,
0,
0,
0,
865,
857,
1,
0,
0,
0,
865,
858,
1,
0,
0,
0,
866,
147,
1,
0,
0,
0,
867,
869,
5,
56,
0,
0,
868,
870,
3,
154,
77,
0,
869,
868,
1,
0,
0,
0,
869,
870,
1,
0,
0,
0,
870,
149,
1,
0,
0,
0,
871,
872,
5,
65,
0,
0,
872,
873,
5,
80,
0,
0,
873,
874,
3,
146,
73,
0,
874,
875,
5,
89,
0,
0,
875,
876,
3,
166,
83,
0,
876,
877,
5,
81,
0,
0,
877,
151,
1,
0,
0,
0,
878,
879,
7,
14,
0,
0,
879,
880,
5,
65,
0,
0,
880,
881,
5,
80,
0,
0,
881,
882,
3,
146,
73,
0,
882,
887,
5,
89,
0,
0,
883,
888,
3,
166,
83,
0,
884,
885,
5,
73,
0,
0,
885,
886,
5,
90,
0,
0,
886,
888,
3,
124,
62,
0,
887,
883,
1,
0,
0,
0,
887,
884,
1,
0,
0,
0,
888,
889,
1,
0,
0,
0,
889,
890,
5,
81,
0,
0,
890,
153,
1,
0,
0,
0,
891,
892,
5,
80,
0,
0,
892,
893,
3,
124,
62,
0,
893,
894,
5,
81,
0,
0,
894,
155,
1,
0,
0,
0,
895,
898,
3,
140,
70,
0,
896,
898,
5,
117,
0,
0,
897,
895,
1,
0,
0,
0,
897,
896,
1,
0,
0,
0,
898,
157,
1,
0,
0,
0,
899,
906,
3,
146,
73,
0,
900,
906,
3,
152,
76,
0,
901,
903,
5,
57,
0,
0,
902,
904,
3,
154,
77,
0,
903,
902,
1,
0,
0,
0,
903,
904,
1,
0,
0,
0,
904,
906,
1,
0,
0,
0,
905,
899,
1,
0,
0,
0,
905,
900,
1,
0,
0,
0,
905,
901,
1,
0,
0,
0,
906,
159,
1,
0,
0,
0,
907,
908,
7,
15,
0,
0,
908,
161,
1,
0,
0,
0,
909,
910,
3,
146,
73,
0,
910,
911,
5,
116,
0,
0,
911,
924,
1,
0,
0,
0,
912,
913,
3,
148,
74,
0,
913,
914,
5,
116,
0,
0,
914,
924,
1,
0,
0,
0,
915,
916,
7,
8,
0,
0,
916,
918,
5,
116,
0,
0,
917,
919,
3,
154,
77,
0,
918,
917,
1,
0,
0,
0,
918,
919,
1,
0,
0,
0,
919,
924,
1,
0,
0,
0,
920,
921,
3,
152,
76,
0,
921,
922,
5,
116,
0,
0,
922,
924,
1,
0,
0,
0,
923,
909,
1,
0,
0,
0,
923,
912,
1,
0,
0,
0,
923,
915,
1,
0,
0,
0,
923,
920,
1,
0,
0,
0,
924,
163,
1,
0,
0,
0,
925,
930,
3,
162,
81,
0,
926,
927,
5,
89,
0,
0,
927,
929,
3,
162,
81,
0,
928,
926,
1,
0,
0,
0,
929,
932,
1,
0,
0,
0,
930,
928,
1,
0,
0,
0,
930,
931,
1,
0,
0,
0,
931,
934,
1,
0,
0,
0,
932,
930,
1,
0,
0,
0,
933,
935,
5,
89,
0,
0,
934,
933,
1,
0,
0,
0,
934,
935,
1,
0,
0,
0,
935,
165,
1,
0,
0,
0,
936,
941,
3,
124,
62,
0,
937,
938,
5,
89,
0,
0,
938,
940,
3,
124,
62,
0,
939,
937,
1,
0,
0,
0,
940,
943,
1,
0,
0,
0,
941,
939,
1,
0,
0,
0,
941,
942,
1,
0,
0,
0,
942,
945,
1,
0,
0,
0,
943,
941,
1,
0,
0,
0,
944,
946,
5,
89,
0,
0,
945,
944,
1,
0,
0,
0,
945,
946,
1,
0,
0,
0,
946,
167,
1,
0,
0,
0,
947,
952,
3,
160,
80,
0,
948,
949,
5,
89,
0,
0,
949,
951,
3,
160,
80,
0,
950,
948,
1,
0,
0,
0,
951,
954,
1,
0,
0,
0,
952,
950,
1,
0,
0,
0,
952,
953,
1,
0,
0,
0,
953,
956,
1,
0,
0,
0,
954,
952,
1,
0,
0,
0,
955,
957,
5,
89,
0,
0,
956,
955,
1,
0,
0,
0,
956,
957,
1,
0,
0,
0,
957,
169,
1,
0,
0,
0,
958,
963,
5,
116,
0,
0,
959,
960,
5,
89,
0,
0,
960,
962,
5,
116,
0,
0,
961,
959,
1,
0,
0,
0,
962,
965,
1,
0,
0,
0,
963,
961,
1,
0,
0,
0,
963,
964,
1,
0,
0,
0,
964,
967,
1,
0,
0,
0,
965,
963,
1,
0,
0,
0,
966,
968,
5,
89,
0,
0,
967,
966,
1,
0,
0,
0,
967,
968,
1,
0,
0,
0,
968,
171,
1,
0,
0,
0,
969,
974,
3,
156,
78,
0,
970,
971,
5,
89,
0,
0,
971,
973,
3,
156,
78,
0,
972,
970,
1,
0,
0,
0,
973,
976,
1,
0,
0,
0,
974,
972,
1,
0,
0,
0,
974,
975,
1,
0,
0,
0,
975,
978,
1,
0,
0,
0,
976,
974,
1,
0,
0,
0,
977,
979,
5,
89,
0,
0,
978,
977,
1,
0,
0,
0,
978,
979,
1,
0,
0,
0,
979,
173,
1,
0,
0,
0,
980,
985,
3,
158,
79,
0,
981,
982,
5,
89,
0,
0,
982,
984,
3,
158,
79,
0,
983,
981,
1,
0,
0,
0,
984,
987,
1,
0,
0,
0,
985,
983,
1,
0,
0,
0,
985,
986,
1,
0,
0,
0,
986,
989,
1,
0,
0,
0,
987,
985,
1,
0,
0,
0,
988,
990,
5,
89,
0,
0,
989,
988,
1,
0,
0,
0,
989,
990,
1,
0,
0,
0,
990,
175,
1,
0,
0,
0,
108,
180,
198,
209,
222,
230,
239,
243,
255,
264,
274,
278,
294,
298,
303,
306,
324,
331,
339,
345,
350,
363,
393,
395,
399,
405,
415,
444,
455,
460,
472,
478,
485,
492,
498,
501,
504,
512,
518,
521,
524,
527,
530,
535,
551,
556,
570,
578,
590,
594,
602,
606,
614,
617,
626,
637,
640,
644,
650,
664,
678,
682,
719,
721,
729,
735,
741,
745,
749,
757,
761,
768,
773,
777,
781,
789,
794,
798,
802,
804,
812,
829,
831,
837,
841,
845,
849,
853,
863,
865,
869,
887,
897,
903,
905,
918,
923,
930,
934,
941,
945,
952,
956,
963,
967,
974,
978,
985,
989,
]
[docs]
class BraketPragmasParser(Parser):
grammarFileName = "BraketPragmasParser.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
sharedContextCache = PredictionContextCache()
literalNames = [
"<INVALID>",
"'braket'",
"'unitary'",
"'result'",
"'noise'",
"'verbatim'",
"'state_vector'",
"'probability'",
"'density_matrix'",
"'amplitude'",
"'expectation'",
"'variance'",
"'sample'",
"'x'",
"'y'",
"'z'",
"'i'",
"'h'",
"'hermitian'",
"'all'",
"'@'",
"'bit_flip'",
"'phase_flip'",
"'pauli_channel'",
"'depolarizing'",
"'two_qubit_depolarizing'",
"'two_qubit_dephasing'",
"'amplitude_damping'",
"'generalized_amplitude_damping'",
"'phase_damping'",
"'kraus'",
"'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>",
"BRAKET",
"UNITARY",
"RESULT",
"NOISE",
"VERBATIM",
"STATE_VECTOR",
"PROBABILITY",
"DENSITY_MATRIX",
"AMPLITUDE",
"EXPECTATION",
"VARIANCE",
"SAMPLE",
"X",
"Y",
"Z",
"I",
"H",
"HERMITIAN",
"ALL",
"AT",
"BIT_FLIP",
"PHASE_FLIP",
"PAULI_CHANNEL",
"DEPOLARIZING",
"TWO_QUBIT_DEPOLARIZING",
"TWO_QUBIT_DEPHASING",
"AMPLITUDE_DAMPING",
"GENERALIZED_AMPLITUDE_DAMPING",
"PHASE_DAMPING",
"KRAUS",
"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",
"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_braketPragma = 0
RULE_braketUnitaryPragma = 1
RULE_braketVerbatimPragma = 2
RULE_twoDimMatrix = 3
RULE_row = 4
RULE_braketResultPragma = 5
RULE_resultType = 6
RULE_noArgResultType = 7
RULE_noArgResultTypeName = 8
RULE_optionalMultiTargetResultType = 9
RULE_optionalMultiTargetResultTypeName = 10
RULE_multiTarget = 11
RULE_multiStateResultType = 12
RULE_multiStateResultTypeName = 13
RULE_multiState = 14
RULE_observableResultType = 15
RULE_observable = 16
RULE_standardObservable = 17
RULE_tensorProductObservable = 18
RULE_hermitianObservable = 19
RULE_observableResultTypeName = 20
RULE_standardObservableName = 21
RULE_complexNumber = 22
RULE_braketNoisePragma = 23
RULE_noiseInstruction = 24
RULE_matrices = 25
RULE_probabilities = 26
RULE_noiseInstructionName = 27
RULE_program = 28
RULE_version = 29
RULE_statement = 30
RULE_annotation = 31
RULE_scope = 32
RULE_pragma = 33
RULE_statementOrScope = 34
RULE_calibrationGrammarStatement = 35
RULE_includeStatement = 36
RULE_breakStatement = 37
RULE_continueStatement = 38
RULE_endStatement = 39
RULE_forStatement = 40
RULE_ifStatement = 41
RULE_returnStatement = 42
RULE_whileStatement = 43
RULE_barrierStatement = 44
RULE_boxStatement = 45
RULE_delayStatement = 46
RULE_gateCallStatement = 47
RULE_measureArrowAssignmentStatement = 48
RULE_resetStatement = 49
RULE_aliasDeclarationStatement = 50
RULE_classicalDeclarationStatement = 51
RULE_constDeclarationStatement = 52
RULE_ioDeclarationStatement = 53
RULE_oldStyleDeclarationStatement = 54
RULE_quantumDeclarationStatement = 55
RULE_defStatement = 56
RULE_externStatement = 57
RULE_gateStatement = 58
RULE_assignmentStatement = 59
RULE_expressionStatement = 60
RULE_defcalStatement = 61
RULE_expression = 62
RULE_aliasExpression = 63
RULE_declarationExpression = 64
RULE_measureExpression = 65
RULE_rangeExpression = 66
RULE_setExpression = 67
RULE_arrayLiteral = 68
RULE_indexOperator = 69
RULE_indexedIdentifier = 70
RULE_returnSignature = 71
RULE_gateModifier = 72
RULE_scalarType = 73
RULE_qubitType = 74
RULE_arrayType = 75
RULE_arrayReferenceType = 76
RULE_designator = 77
RULE_gateOperand = 78
RULE_externArgument = 79
RULE_defcalArgument = 80
RULE_argumentDefinition = 81
RULE_argumentDefinitionList = 82
RULE_expressionList = 83
RULE_defcalArgumentList = 84
RULE_identifierList = 85
RULE_gateOperandList = 86
RULE_externArgumentList = 87
ruleNames = [
"braketPragma",
"braketUnitaryPragma",
"braketVerbatimPragma",
"twoDimMatrix",
"row",
"braketResultPragma",
"resultType",
"noArgResultType",
"noArgResultTypeName",
"optionalMultiTargetResultType",
"optionalMultiTargetResultTypeName",
"multiTarget",
"multiStateResultType",
"multiStateResultTypeName",
"multiState",
"observableResultType",
"observable",
"standardObservable",
"tensorProductObservable",
"hermitianObservable",
"observableResultTypeName",
"standardObservableName",
"complexNumber",
"braketNoisePragma",
"noiseInstruction",
"matrices",
"probabilities",
"noiseInstructionName",
"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
BRAKET = 1
UNITARY = 2
RESULT = 3
NOISE = 4
VERBATIM = 5
STATE_VECTOR = 6
PROBABILITY = 7
DENSITY_MATRIX = 8
AMPLITUDE = 9
EXPECTATION = 10
VARIANCE = 11
SAMPLE = 12
X = 13
Y = 14
Z = 15
I = 16
H = 17
HERMITIAN = 18
ALL = 19
AT = 20
BIT_FLIP = 21
PHASE_FLIP = 22
PAULI_CHANNEL = 23
DEPOLARIZING = 24
TWO_QUBIT_DEPOLARIZING = 25
TWO_QUBIT_DEPHASING = 26
AMPLITUDE_DAMPING = 27
GENERALIZED_AMPLITUDE_DAMPING = 28
PHASE_DAMPING = 29
KRAUS = 30
OPENQASM = 31
INCLUDE = 32
DEFCALGRAMMAR = 33
DEF = 34
DEFCAL = 35
GATE = 36
EXTERN = 37
BOX = 38
LET = 39
BREAK = 40
CONTINUE = 41
IF = 42
ELSE = 43
END = 44
RETURN = 45
FOR = 46
WHILE = 47
IN = 48
PRAGMA = 49
AnnotationKeyword = 50
INPUT = 51
OUTPUT = 52
CONST = 53
MUTABLE = 54
QREG = 55
QUBIT = 56
CREG = 57
BOOL = 58
BIT = 59
INT = 60
UINT = 61
FLOAT = 62
ANGLE = 63
COMPLEX = 64
ARRAY = 65
DURATION = 66
STRETCH = 67
GPHASE = 68
INV = 69
POW = 70
CTRL = 71
NEGCTRL = 72
DIM = 73
DURATIONOF = 74
DELAY = 75
RESET = 76
MEASURE = 77
BARRIER = 78
BooleanLiteral = 79
LBRACKET = 80
RBRACKET = 81
LBRACE = 82
RBRACE = 83
LPAREN = 84
RPAREN = 85
COLON = 86
SEMICOLON = 87
DOT = 88
COMMA = 89
EQUALS = 90
ARROW = 91
PLUS = 92
DOUBLE_PLUS = 93
MINUS = 94
ASTERISK = 95
DOUBLE_ASTERISK = 96
SLASH = 97
PERCENT = 98
PIPE = 99
DOUBLE_PIPE = 100
AMPERSAND = 101
DOUBLE_AMPERSAND = 102
CARET = 103
TILDE = 104
EXCLAMATION_POINT = 105
EqualityOperator = 106
CompoundAssignmentOperator = 107
ComparisonOperator = 108
BitshiftOperator = 109
IMAG = 110
ImaginaryLiteral = 111
BinaryIntegerLiteral = 112
OctalIntegerLiteral = 113
DecimalIntegerLiteral = 114
HexIntegerLiteral = 115
Identifier = 116
HardwareQubit = 117
FloatLiteral = 118
TimingLiteral = 119
BitstringLiteral = 120
StringLiteral = 121
Whitespace = 122
Newline = 123
LineComment = 124
BlockComment = 125
VERSION_IDENTIFER_WHITESPACE = 126
VersionSpecifier = 127
EAT_INITIAL_SPACE = 128
EAT_LINE_END = 129
RemainingLineContent = 130
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 BraketPragmaContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def braketResultPragma(self):
return self.getTypedRuleContext(BraketPragmasParser.BraketResultPragmaContext, 0)
[docs]
def braketUnitaryPragma(self):
return self.getTypedRuleContext(BraketPragmasParser.BraketUnitaryPragmaContext, 0)
[docs]
def braketNoisePragma(self):
return self.getTypedRuleContext(BraketPragmasParser.BraketNoisePragmaContext, 0)
[docs]
def braketVerbatimPragma(self):
return self.getTypedRuleContext(BraketPragmasParser.BraketVerbatimPragmaContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_braketPragma
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBraketPragma"):
return visitor.visitBraketPragma(self)
else:
return visitor.visitChildren(self)
[docs]
def braketPragma(self):
localctx = BraketPragmasParser.BraketPragmaContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_braketPragma)
try:
self.state = 180
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 0, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 176
self.braketResultPragma()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 177
self.braketUnitaryPragma()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 178
self.braketNoisePragma()
pass
elif la_ == 4:
self.enterOuterAlt(localctx, 4)
self.state = 179
self.braketVerbatimPragma()
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 BraketUnitaryPragmaContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BRAKET(self):
return self.getToken(BraketPragmasParser.BRAKET, 0)
[docs]
def UNITARY(self):
return self.getToken(BraketPragmasParser.UNITARY, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def twoDimMatrix(self):
return self.getTypedRuleContext(BraketPragmasParser.TwoDimMatrixContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def multiTarget(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiTargetContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_braketUnitaryPragma
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBraketUnitaryPragma"):
return visitor.visitBraketUnitaryPragma(self)
else:
return visitor.visitChildren(self)
[docs]
def braketUnitaryPragma(self):
localctx = BraketPragmasParser.BraketUnitaryPragmaContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_braketUnitaryPragma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 182
self.match(BraketPragmasParser.BRAKET)
self.state = 183
self.match(BraketPragmasParser.UNITARY)
self.state = 184
self.match(BraketPragmasParser.LPAREN)
self.state = 185
self.twoDimMatrix()
self.state = 186
self.match(BraketPragmasParser.RPAREN)
self.state = 187
self.multiTarget()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class BraketVerbatimPragmaContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BRAKET(self):
return self.getToken(BraketPragmasParser.BRAKET, 0)
[docs]
def VERBATIM(self):
return self.getToken(BraketPragmasParser.VERBATIM, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_braketVerbatimPragma
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBraketVerbatimPragma"):
return visitor.visitBraketVerbatimPragma(self)
else:
return visitor.visitChildren(self)
[docs]
def braketVerbatimPragma(self):
localctx = BraketPragmasParser.BraketVerbatimPragmaContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_braketVerbatimPragma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 189
self.match(BraketPragmasParser.BRAKET)
self.state = 190
self.match(BraketPragmasParser.VERBATIM)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TwoDimMatrixContext(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(BraketPragmasParser.LBRACKET, 0)
[docs]
def row(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.RowContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.RowContext, i)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_twoDimMatrix
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitTwoDimMatrix"):
return visitor.visitTwoDimMatrix(self)
else:
return visitor.visitChildren(self)
[docs]
def twoDimMatrix(self):
localctx = BraketPragmasParser.TwoDimMatrixContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_twoDimMatrix)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 192
self.match(BraketPragmasParser.LBRACKET)
self.state = 193
self.row()
self.state = 198
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 89:
self.state = 194
self.match(BraketPragmasParser.COMMA)
self.state = 195
self.row()
self.state = 200
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 201
self.match(BraketPragmasParser.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 RowContext(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(BraketPragmasParser.LBRACKET, 0)
[docs]
def complexNumber(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.ComplexNumberContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ComplexNumberContext, i)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_row
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitRow"):
return visitor.visitRow(self)
else:
return visitor.visitChildren(self)
[docs]
def row(self):
localctx = BraketPragmasParser.RowContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_row)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 203
self.match(BraketPragmasParser.LBRACKET)
self.state = 204
self.complexNumber()
self.state = 209
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 89:
self.state = 205
self.match(BraketPragmasParser.COMMA)
self.state = 206
self.complexNumber()
self.state = 211
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 212
self.match(BraketPragmasParser.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 BraketResultPragmaContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BRAKET(self):
return self.getToken(BraketPragmasParser.BRAKET, 0)
[docs]
def RESULT(self):
return self.getToken(BraketPragmasParser.RESULT, 0)
[docs]
def resultType(self):
return self.getTypedRuleContext(BraketPragmasParser.ResultTypeContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_braketResultPragma
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBraketResultPragma"):
return visitor.visitBraketResultPragma(self)
else:
return visitor.visitChildren(self)
[docs]
def braketResultPragma(self):
localctx = BraketPragmasParser.BraketResultPragmaContext(self, self._ctx, self.state)
self.enterRule(localctx, 10, self.RULE_braketResultPragma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 214
self.match(BraketPragmasParser.BRAKET)
self.state = 215
self.match(BraketPragmasParser.RESULT)
self.state = 216
self.resultType()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ResultTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def noArgResultType(self):
return self.getTypedRuleContext(BraketPragmasParser.NoArgResultTypeContext, 0)
[docs]
def optionalMultiTargetResultType(self):
return self.getTypedRuleContext(
BraketPragmasParser.OptionalMultiTargetResultTypeContext, 0
)
[docs]
def multiStateResultType(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiStateResultTypeContext, 0)
[docs]
def observableResultType(self):
return self.getTypedRuleContext(BraketPragmasParser.ObservableResultTypeContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_resultType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitResultType"):
return visitor.visitResultType(self)
else:
return visitor.visitChildren(self)
[docs]
def resultType(self):
localctx = BraketPragmasParser.ResultTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_resultType)
try:
self.state = 222
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [6]:
self.enterOuterAlt(localctx, 1)
self.state = 218
self.noArgResultType()
pass
elif token in [7, 8]:
self.enterOuterAlt(localctx, 2)
self.state = 219
self.optionalMultiTargetResultType()
pass
elif token in [9]:
self.enterOuterAlt(localctx, 3)
self.state = 220
self.multiStateResultType()
pass
elif token in [10, 11, 12]:
self.enterOuterAlt(localctx, 4)
self.state = 221
self.observableResultType()
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 NoArgResultTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def noArgResultTypeName(self):
return self.getTypedRuleContext(BraketPragmasParser.NoArgResultTypeNameContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_noArgResultType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitNoArgResultType"):
return visitor.visitNoArgResultType(self)
else:
return visitor.visitChildren(self)
[docs]
def noArgResultType(self):
localctx = BraketPragmasParser.NoArgResultTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_noArgResultType)
try:
self.enterOuterAlt(localctx, 1)
self.state = 224
self.noArgResultTypeName()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NoArgResultTypeNameContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STATE_VECTOR(self):
return self.getToken(BraketPragmasParser.STATE_VECTOR, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_noArgResultTypeName
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitNoArgResultTypeName"):
return visitor.visitNoArgResultTypeName(self)
else:
return visitor.visitChildren(self)
[docs]
def noArgResultTypeName(self):
localctx = BraketPragmasParser.NoArgResultTypeNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_noArgResultTypeName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 226
self.match(BraketPragmasParser.STATE_VECTOR)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OptionalMultiTargetResultTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def optionalMultiTargetResultTypeName(self):
return self.getTypedRuleContext(
BraketPragmasParser.OptionalMultiTargetResultTypeNameContext, 0
)
[docs]
def multiTarget(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiTargetContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_optionalMultiTargetResultType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitOptionalMultiTargetResultType"):
return visitor.visitOptionalMultiTargetResultType(self)
else:
return visitor.visitChildren(self)
[docs]
def optionalMultiTargetResultType(self):
localctx = BraketPragmasParser.OptionalMultiTargetResultTypeContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 18, self.RULE_optionalMultiTargetResultType)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 228
self.optionalMultiTargetResultTypeName()
self.state = 230
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 19 or _la == 116 or _la == 117:
self.state = 229
self.multiTarget()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class OptionalMultiTargetResultTypeNameContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def PROBABILITY(self):
return self.getToken(BraketPragmasParser.PROBABILITY, 0)
[docs]
def DENSITY_MATRIX(self):
return self.getToken(BraketPragmasParser.DENSITY_MATRIX, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_optionalMultiTargetResultTypeName
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitOptionalMultiTargetResultTypeName"):
return visitor.visitOptionalMultiTargetResultTypeName(self)
else:
return visitor.visitChildren(self)
[docs]
def optionalMultiTargetResultTypeName(self):
localctx = BraketPragmasParser.OptionalMultiTargetResultTypeNameContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 20, self.RULE_optionalMultiTargetResultTypeName)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 232
_la = self._input.LA(1)
if not (_la == 7 or _la == 8):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MultiTargetContext(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 BraketPragmasParser.RULE_multiTarget
[docs]
def copyFrom(self, ctx: ParserRuleContext):
super().copyFrom(ctx)
[docs]
class MultiTargetAllContext(MultiTargetContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.MultiTargetContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def ALL(self):
return self.getToken(BraketPragmasParser.ALL, 0)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMultiTargetAll"):
return visitor.visitMultiTargetAll(self)
else:
return visitor.visitChildren(self)
[docs]
class MultiTargetIdentifiersContext(MultiTargetContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.MultiTargetContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def gateOperand(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.GateOperandContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.GateOperandContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMultiTargetIdentifiers"):
return visitor.visitMultiTargetIdentifiers(self)
else:
return visitor.visitChildren(self)
[docs]
def multiTarget(self):
localctx = BraketPragmasParser.MultiTargetContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_multiTarget)
self._la = 0 # Token type
try:
self.state = 243
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [116, 117]:
localctx = BraketPragmasParser.MultiTargetIdentifiersContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 234
self.gateOperand()
self.state = 239
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 89:
self.state = 235
self.match(BraketPragmasParser.COMMA)
self.state = 236
self.gateOperand()
self.state = 241
self._errHandler.sync(self)
_la = self._input.LA(1)
pass
elif token in [19]:
localctx = BraketPragmasParser.MultiTargetAllContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 242
self.match(BraketPragmasParser.ALL)
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 MultiStateResultTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def multiStateResultTypeName(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiStateResultTypeNameContext, 0)
[docs]
def multiState(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiStateContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_multiStateResultType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMultiStateResultType"):
return visitor.visitMultiStateResultType(self)
else:
return visitor.visitChildren(self)
[docs]
def multiStateResultType(self):
localctx = BraketPragmasParser.MultiStateResultTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_multiStateResultType)
try:
self.enterOuterAlt(localctx, 1)
self.state = 245
self.multiStateResultTypeName()
self.state = 246
self.multiState()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MultiStateResultTypeNameContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def AMPLITUDE(self):
return self.getToken(BraketPragmasParser.AMPLITUDE, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_multiStateResultTypeName
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMultiStateResultTypeName"):
return visitor.visitMultiStateResultTypeName(self)
else:
return visitor.visitChildren(self)
[docs]
def multiStateResultTypeName(self):
localctx = BraketPragmasParser.MultiStateResultTypeNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_multiStateResultTypeName)
try:
self.enterOuterAlt(localctx, 1)
self.state = 248
self.match(BraketPragmasParser.AMPLITUDE)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class MultiStateContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BitstringLiteral(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.BitstringLiteral)
else:
return self.getToken(BraketPragmasParser.BitstringLiteral, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_multiState
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMultiState"):
return visitor.visitMultiState(self)
else:
return visitor.visitChildren(self)
[docs]
def multiState(self):
localctx = BraketPragmasParser.MultiStateContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_multiState)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 250
self.match(BraketPragmasParser.BitstringLiteral)
self.state = 255
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 89:
self.state = 251
self.match(BraketPragmasParser.COMMA)
self.state = 252
self.match(BraketPragmasParser.BitstringLiteral)
self.state = 257
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 ObservableResultTypeContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def observableResultTypeName(self):
return self.getTypedRuleContext(BraketPragmasParser.ObservableResultTypeNameContext, 0)
[docs]
def observable(self):
return self.getTypedRuleContext(BraketPragmasParser.ObservableContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_observableResultType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitObservableResultType"):
return visitor.visitObservableResultType(self)
else:
return visitor.visitChildren(self)
[docs]
def observableResultType(self):
localctx = BraketPragmasParser.ObservableResultTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_observableResultType)
try:
self.enterOuterAlt(localctx, 1)
self.state = 258
self.observableResultTypeName()
self.state = 259
self.observable()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ObservableContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def standardObservable(self):
return self.getTypedRuleContext(BraketPragmasParser.StandardObservableContext, 0)
[docs]
def tensorProductObservable(self):
return self.getTypedRuleContext(BraketPragmasParser.TensorProductObservableContext, 0)
[docs]
def hermitianObservable(self):
return self.getTypedRuleContext(BraketPragmasParser.HermitianObservableContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_observable
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitObservable"):
return visitor.visitObservable(self)
else:
return visitor.visitChildren(self)
[docs]
def observable(self):
localctx = BraketPragmasParser.ObservableContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_observable)
try:
self.state = 264
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 8, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 261
self.standardObservable()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 262
self.tensorProductObservable()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 263
self.hermitianObservable()
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 StandardObservableContext(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 BraketPragmasParser.RULE_standardObservable
[docs]
def copyFrom(self, ctx: ParserRuleContext):
super().copyFrom(ctx)
[docs]
class StandardObservableAllContext(StandardObservableContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.StandardObservableContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def standardObservableName(self):
return self.getTypedRuleContext(BraketPragmasParser.StandardObservableNameContext, 0)
[docs]
def ALL(self):
return self.getToken(BraketPragmasParser.ALL, 0)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitStandardObservableAll"):
return visitor.visitStandardObservableAll(self)
else:
return visitor.visitChildren(self)
[docs]
class StandardObservableIdentifierContext(StandardObservableContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.StandardObservableContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def standardObservableName(self):
return self.getTypedRuleContext(BraketPragmasParser.StandardObservableNameContext, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def gateOperand(self):
return self.getTypedRuleContext(BraketPragmasParser.GateOperandContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitStandardObservableIdentifier"):
return visitor.visitStandardObservableIdentifier(self)
else:
return visitor.visitChildren(self)
[docs]
def standardObservable(self):
localctx = BraketPragmasParser.StandardObservableContext(self, self._ctx, self.state)
self.enterRule(localctx, 34, self.RULE_standardObservable)
try:
self.state = 274
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 9, self._ctx)
if la_ == 1:
localctx = BraketPragmasParser.StandardObservableIdentifierContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 266
self.standardObservableName()
self.state = 267
self.match(BraketPragmasParser.LPAREN)
self.state = 268
self.gateOperand()
self.state = 269
self.match(BraketPragmasParser.RPAREN)
pass
elif la_ == 2:
localctx = BraketPragmasParser.StandardObservableAllContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 271
self.standardObservableName()
self.state = 272
self.match(BraketPragmasParser.ALL)
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 TensorProductObservableContext(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(BraketPragmasParser.AT, 0)
[docs]
def observable(self):
return self.getTypedRuleContext(BraketPragmasParser.ObservableContext, 0)
[docs]
def standardObservable(self):
return self.getTypedRuleContext(BraketPragmasParser.StandardObservableContext, 0)
[docs]
def hermitianObservable(self):
return self.getTypedRuleContext(BraketPragmasParser.HermitianObservableContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_tensorProductObservable
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitTensorProductObservable"):
return visitor.visitTensorProductObservable(self)
else:
return visitor.visitChildren(self)
[docs]
def tensorProductObservable(self):
localctx = BraketPragmasParser.TensorProductObservableContext(self, self._ctx, self.state)
self.enterRule(localctx, 36, self.RULE_tensorProductObservable)
try:
self.enterOuterAlt(localctx, 1)
self.state = 278
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [13, 14, 15, 16, 17]:
self.state = 276
self.standardObservable()
pass
elif token in [18]:
self.state = 277
self.hermitianObservable()
pass
else:
raise NoViableAltException(self)
self.state = 280
self.match(BraketPragmasParser.AT)
self.state = 281
self.observable()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class HermitianObservableContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def HERMITIAN(self):
return self.getToken(BraketPragmasParser.HERMITIAN, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def twoDimMatrix(self):
return self.getTypedRuleContext(BraketPragmasParser.TwoDimMatrixContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def multiTarget(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiTargetContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_hermitianObservable
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitHermitianObservable"):
return visitor.visitHermitianObservable(self)
else:
return visitor.visitChildren(self)
[docs]
def hermitianObservable(self):
localctx = BraketPragmasParser.HermitianObservableContext(self, self._ctx, self.state)
self.enterRule(localctx, 38, self.RULE_hermitianObservable)
try:
self.enterOuterAlt(localctx, 1)
self.state = 283
self.match(BraketPragmasParser.HERMITIAN)
self.state = 284
self.match(BraketPragmasParser.LPAREN)
self.state = 285
self.twoDimMatrix()
self.state = 286
self.match(BraketPragmasParser.RPAREN)
self.state = 287
self.multiTarget()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ObservableResultTypeNameContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EXPECTATION(self):
return self.getToken(BraketPragmasParser.EXPECTATION, 0)
[docs]
def VARIANCE(self):
return self.getToken(BraketPragmasParser.VARIANCE, 0)
[docs]
def SAMPLE(self):
return self.getToken(BraketPragmasParser.SAMPLE, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_observableResultTypeName
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitObservableResultTypeName"):
return visitor.visitObservableResultTypeName(self)
else:
return visitor.visitChildren(self)
[docs]
def observableResultTypeName(self):
localctx = BraketPragmasParser.ObservableResultTypeNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_observableResultTypeName)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 289
_la = self._input.LA(1)
if not (((_la) & ~0x3F) == 0 and ((1 << _la) & 7168) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class StandardObservableNameContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def X(self):
return self.getToken(BraketPragmasParser.X, 0)
[docs]
def Y(self):
return self.getToken(BraketPragmasParser.Y, 0)
[docs]
def Z(self):
return self.getToken(BraketPragmasParser.Z, 0)
[docs]
def I(self):
return self.getToken(BraketPragmasParser.I, 0)
[docs]
def H(self):
return self.getToken(BraketPragmasParser.H, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_standardObservableName
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitStandardObservableName"):
return visitor.visitStandardObservableName(self)
else:
return visitor.visitChildren(self)
[docs]
def standardObservableName(self):
localctx = BraketPragmasParser.StandardObservableNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 42, self.RULE_standardObservableName)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 291
_la = self._input.LA(1)
if not (((_la) & ~0x3F) == 0 and ((1 << _la) & 253952) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ComplexNumberContext(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 BraketPragmasParser.RULE_complexNumber
[docs]
def copyFrom(self, ctx: ParserRuleContext):
super().copyFrom(ctx)
[docs]
class ComplexOneValueContext(ComplexNumberContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.ComplexNumberContext
super().__init__(parser)
self.neg = None # Token
self.value = None # Token
self.copyFrom(ctx)
[docs]
def DecimalIntegerLiteral(self):
return self.getToken(BraketPragmasParser.DecimalIntegerLiteral, 0)
[docs]
def FloatLiteral(self):
return self.getToken(BraketPragmasParser.FloatLiteral, 0)
[docs]
def ImaginaryLiteral(self):
return self.getToken(BraketPragmasParser.ImaginaryLiteral, 0)
[docs]
def MINUS(self):
return self.getToken(BraketPragmasParser.MINUS, 0)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitComplexOneValue"):
return visitor.visitComplexOneValue(self)
else:
return visitor.visitChildren(self)
[docs]
class ComplexTwoValuesContext(ComplexNumberContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.ComplexNumberContext
super().__init__(parser)
self.neg = None # Token
self.real = None # Token
self.sign = None # Token
self.imagNeg = None # Token
self.imag = None # Token
self.copyFrom(ctx)
[docs]
def ImaginaryLiteral(self):
return self.getToken(BraketPragmasParser.ImaginaryLiteral, 0)
[docs]
def DecimalIntegerLiteral(self):
return self.getToken(BraketPragmasParser.DecimalIntegerLiteral, 0)
[docs]
def FloatLiteral(self):
return self.getToken(BraketPragmasParser.FloatLiteral, 0)
[docs]
def PLUS(self):
return self.getToken(BraketPragmasParser.PLUS, 0)
[docs]
def MINUS(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.MINUS)
else:
return self.getToken(BraketPragmasParser.MINUS, i)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitComplexTwoValues"):
return visitor.visitComplexTwoValues(self)
else:
return visitor.visitChildren(self)
[docs]
def complexNumber(self):
localctx = BraketPragmasParser.ComplexNumberContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_complexNumber)
self._la = 0 # Token type
try:
self.state = 306
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 14, self._ctx)
if la_ == 1:
localctx = BraketPragmasParser.ComplexOneValueContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 294
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 94:
self.state = 293
localctx.neg = self.match(BraketPragmasParser.MINUS)
self.state = 296
localctx.value = self._input.LT(1)
_la = self._input.LA(1)
if not (((_la - 111) & ~0x3F) == 0 and ((1 << (_la - 111)) & 137) != 0):
localctx.value = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
elif la_ == 2:
localctx = BraketPragmasParser.ComplexTwoValuesContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 298
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 94:
self.state = 297
localctx.neg = self.match(BraketPragmasParser.MINUS)
self.state = 300
localctx.real = self._input.LT(1)
_la = self._input.LA(1)
if not (_la == 114 or _la == 118):
localctx.real = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 301
localctx.sign = self._input.LT(1)
_la = self._input.LA(1)
if not (_la == 92 or _la == 94):
localctx.sign = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 303
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 94:
self.state = 302
localctx.imagNeg = self.match(BraketPragmasParser.MINUS)
self.state = 305
localctx.imag = self.match(BraketPragmasParser.ImaginaryLiteral)
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 BraketNoisePragmaContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BRAKET(self):
return self.getToken(BraketPragmasParser.BRAKET, 0)
[docs]
def NOISE(self):
return self.getToken(BraketPragmasParser.NOISE, 0)
[docs]
def noiseInstruction(self):
return self.getTypedRuleContext(BraketPragmasParser.NoiseInstructionContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_braketNoisePragma
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBraketNoisePragma"):
return visitor.visitBraketNoisePragma(self)
else:
return visitor.visitChildren(self)
[docs]
def braketNoisePragma(self):
localctx = BraketPragmasParser.BraketNoisePragmaContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_braketNoisePragma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 308
self.match(BraketPragmasParser.BRAKET)
self.state = 309
self.match(BraketPragmasParser.NOISE)
self.state = 310
self.noiseInstruction()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NoiseInstructionContext(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 BraketPragmasParser.RULE_noiseInstruction
[docs]
def copyFrom(self, ctx: ParserRuleContext):
super().copyFrom(ctx)
[docs]
class NoiseContext(NoiseInstructionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.NoiseInstructionContext
super().__init__(parser)
self.target = None # MultiTargetContext
self.copyFrom(ctx)
[docs]
def noiseInstructionName(self):
return self.getTypedRuleContext(BraketPragmasParser.NoiseInstructionNameContext, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def probabilities(self):
return self.getTypedRuleContext(BraketPragmasParser.ProbabilitiesContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def multiTarget(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiTargetContext, 0)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitNoise"):
return visitor.visitNoise(self)
else:
return visitor.visitChildren(self)
[docs]
class KrausContext(NoiseInstructionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.NoiseInstructionContext
super().__init__(parser)
self.target = None # MultiTargetContext
self.copyFrom(ctx)
[docs]
def KRAUS(self):
return self.getToken(BraketPragmasParser.KRAUS, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def matrices(self):
return self.getTypedRuleContext(BraketPragmasParser.MatricesContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def multiTarget(self):
return self.getTypedRuleContext(BraketPragmasParser.MultiTargetContext, 0)
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitKraus"):
return visitor.visitKraus(self)
else:
return visitor.visitChildren(self)
[docs]
def noiseInstruction(self):
localctx = BraketPragmasParser.NoiseInstructionContext(self, self._ctx, self.state)
self.enterRule(localctx, 48, self.RULE_noiseInstruction)
try:
self.state = 324
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [21, 22, 23, 24, 25, 26, 27, 28, 29]:
localctx = BraketPragmasParser.NoiseContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 312
self.noiseInstructionName()
self.state = 313
self.match(BraketPragmasParser.LPAREN)
self.state = 314
self.probabilities()
self.state = 315
self.match(BraketPragmasParser.RPAREN)
self.state = 316
localctx.target = self.multiTarget()
pass
elif token in [30]:
localctx = BraketPragmasParser.KrausContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 318
self.match(BraketPragmasParser.KRAUS)
self.state = 319
self.match(BraketPragmasParser.LPAREN)
self.state = 320
self.matrices()
self.state = 321
self.match(BraketPragmasParser.RPAREN)
self.state = 322
localctx.target = self.multiTarget()
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 MatricesContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def twoDimMatrix(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.TwoDimMatrixContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.TwoDimMatrixContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_matrices
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMatrices"):
return visitor.visitMatrices(self)
else:
return visitor.visitChildren(self)
[docs]
def matrices(self):
localctx = BraketPragmasParser.MatricesContext(self, self._ctx, self.state)
self.enterRule(localctx, 50, self.RULE_matrices)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 326
self.twoDimMatrix()
self.state = 331
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 89:
self.state = 327
self.match(BraketPragmasParser.COMMA)
self.state = 328
self.twoDimMatrix()
self.state = 333
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 ProbabilitiesContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FloatLiteral(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.FloatLiteral)
else:
return self.getToken(BraketPragmasParser.FloatLiteral, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_probabilities
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitProbabilities"):
return visitor.visitProbabilities(self)
else:
return visitor.visitChildren(self)
[docs]
def probabilities(self):
localctx = BraketPragmasParser.ProbabilitiesContext(self, self._ctx, self.state)
self.enterRule(localctx, 52, self.RULE_probabilities)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 334
self.match(BraketPragmasParser.FloatLiteral)
self.state = 339
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 89:
self.state = 335
self.match(BraketPragmasParser.COMMA)
self.state = 336
self.match(BraketPragmasParser.FloatLiteral)
self.state = 341
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 NoiseInstructionNameContext(ParserRuleContext):
__slots__ = "parser"
def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def BIT_FLIP(self):
return self.getToken(BraketPragmasParser.BIT_FLIP, 0)
[docs]
def PHASE_FLIP(self):
return self.getToken(BraketPragmasParser.PHASE_FLIP, 0)
[docs]
def PAULI_CHANNEL(self):
return self.getToken(BraketPragmasParser.PAULI_CHANNEL, 0)
[docs]
def DEPOLARIZING(self):
return self.getToken(BraketPragmasParser.DEPOLARIZING, 0)
[docs]
def TWO_QUBIT_DEPOLARIZING(self):
return self.getToken(BraketPragmasParser.TWO_QUBIT_DEPOLARIZING, 0)
[docs]
def TWO_QUBIT_DEPHASING(self):
return self.getToken(BraketPragmasParser.TWO_QUBIT_DEPHASING, 0)
[docs]
def AMPLITUDE_DAMPING(self):
return self.getToken(BraketPragmasParser.AMPLITUDE_DAMPING, 0)
[docs]
def GENERALIZED_AMPLITUDE_DAMPING(self):
return self.getToken(BraketPragmasParser.GENERALIZED_AMPLITUDE_DAMPING, 0)
[docs]
def PHASE_DAMPING(self):
return self.getToken(BraketPragmasParser.PHASE_DAMPING, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_noiseInstructionName
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitNoiseInstructionName"):
return visitor.visitNoiseInstructionName(self)
else:
return visitor.visitChildren(self)
[docs]
def noiseInstructionName(self):
localctx = BraketPragmasParser.NoiseInstructionNameContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_noiseInstructionName)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 342
_la = self._input.LA(1)
if not (((_la) & ~0x3F) == 0 and ((1 << _la) & 1071644672) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[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(BraketPragmasParser.EOF, 0)
[docs]
def version(self):
return self.getTypedRuleContext(BraketPragmasParser.VersionContext, 0)
[docs]
def statement(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.StatementContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.StatementContext, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_program
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitProgram"):
return visitor.visitProgram(self)
else:
return visitor.visitChildren(self)
[docs]
def program(self):
localctx = BraketPragmasParser.ProgramContext(self, self._ctx, self.state)
self.enterRule(localctx, 56, self.RULE_program)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 345
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 31:
self.state = 344
self.version()
self.state = 350
self._errHandler.sync(self)
_la = self._input.LA(1)
while (((_la) & ~0x3F) == 0 and ((1 << _la) & -18304673874182144) != 0) or (
((_la - 64) & ~0x3F) == 0 and ((1 << (_la - 64)) & 143977750197239295) != 0
):
self.state = 347
self.statement()
self.state = 352
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 353
self.match(BraketPragmasParser.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(BraketPragmasParser.OPENQASM, 0)
[docs]
def VersionSpecifier(self):
return self.getToken(BraketPragmasParser.VersionSpecifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_version
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitVersion"):
return visitor.visitVersion(self)
else:
return visitor.visitChildren(self)
[docs]
def version(self):
localctx = BraketPragmasParser.VersionContext(self, self._ctx, self.state)
self.enterRule(localctx, 58, self.RULE_version)
try:
self.enterOuterAlt(localctx, 1)
self.state = 355
self.match(BraketPragmasParser.OPENQASM)
self.state = 356
self.match(BraketPragmasParser.VersionSpecifier)
self.state = 357
self.match(BraketPragmasParser.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(BraketPragmasParser.PragmaContext, 0)
[docs]
def aliasDeclarationStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.AliasDeclarationStatementContext, 0)
[docs]
def assignmentStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.AssignmentStatementContext, 0)
[docs]
def barrierStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.BarrierStatementContext, 0)
[docs]
def boxStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.BoxStatementContext, 0)
[docs]
def breakStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.BreakStatementContext, 0)
[docs]
def calibrationGrammarStatement(self):
return self.getTypedRuleContext(
BraketPragmasParser.CalibrationGrammarStatementContext, 0
)
[docs]
def classicalDeclarationStatement(self):
return self.getTypedRuleContext(
BraketPragmasParser.ClassicalDeclarationStatementContext, 0
)
[docs]
def constDeclarationStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.ConstDeclarationStatementContext, 0)
[docs]
def continueStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.ContinueStatementContext, 0)
[docs]
def defStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.DefStatementContext, 0)
[docs]
def defcalStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.DefcalStatementContext, 0)
[docs]
def delayStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.DelayStatementContext, 0)
[docs]
def endStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.EndStatementContext, 0)
[docs]
def expressionStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionStatementContext, 0)
[docs]
def externStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.ExternStatementContext, 0)
[docs]
def forStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.ForStatementContext, 0)
[docs]
def gateCallStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.GateCallStatementContext, 0)
[docs]
def gateStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.GateStatementContext, 0)
[docs]
def ifStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.IfStatementContext, 0)
[docs]
def includeStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.IncludeStatementContext, 0)
[docs]
def ioDeclarationStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.IoDeclarationStatementContext, 0)
[docs]
def measureArrowAssignmentStatement(self):
return self.getTypedRuleContext(
BraketPragmasParser.MeasureArrowAssignmentStatementContext, 0
)
[docs]
def oldStyleDeclarationStatement(self):
return self.getTypedRuleContext(
BraketPragmasParser.OldStyleDeclarationStatementContext, 0
)
[docs]
def quantumDeclarationStatement(self):
return self.getTypedRuleContext(
BraketPragmasParser.QuantumDeclarationStatementContext, 0
)
[docs]
def resetStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.ResetStatementContext, 0)
[docs]
def returnStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.ReturnStatementContext, 0)
[docs]
def whileStatement(self):
return self.getTypedRuleContext(BraketPragmasParser.WhileStatementContext, 0)
[docs]
def annotation(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.AnnotationContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.AnnotationContext, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_statement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitStatement"):
return visitor.visitStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def statement(self):
localctx = BraketPragmasParser.StatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_statement)
self._la = 0 # Token type
try:
self.state = 395
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [49]:
self.enterOuterAlt(localctx, 1)
self.state = 359
self.pragma()
pass
elif token in [
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
44,
45,
46,
47,
50,
51,
52,
53,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
74,
75,
76,
77,
78,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.enterOuterAlt(localctx, 2)
self.state = 363
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 50:
self.state = 360
self.annotation()
self.state = 365
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 393
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 21, self._ctx)
if la_ == 1:
self.state = 366
self.aliasDeclarationStatement()
pass
elif la_ == 2:
self.state = 367
self.assignmentStatement()
pass
elif la_ == 3:
self.state = 368
self.barrierStatement()
pass
elif la_ == 4:
self.state = 369
self.boxStatement()
pass
elif la_ == 5:
self.state = 370
self.breakStatement()
pass
elif la_ == 6:
self.state = 371
self.calibrationGrammarStatement()
pass
elif la_ == 7:
self.state = 372
self.classicalDeclarationStatement()
pass
elif la_ == 8:
self.state = 373
self.constDeclarationStatement()
pass
elif la_ == 9:
self.state = 374
self.continueStatement()
pass
elif la_ == 10:
self.state = 375
self.defStatement()
pass
elif la_ == 11:
self.state = 376
self.defcalStatement()
pass
elif la_ == 12:
self.state = 377
self.delayStatement()
pass
elif la_ == 13:
self.state = 378
self.endStatement()
pass
elif la_ == 14:
self.state = 379
self.expressionStatement()
pass
elif la_ == 15:
self.state = 380
self.externStatement()
pass
elif la_ == 16:
self.state = 381
self.forStatement()
pass
elif la_ == 17:
self.state = 382
self.gateCallStatement()
pass
elif la_ == 18:
self.state = 383
self.gateStatement()
pass
elif la_ == 19:
self.state = 384
self.ifStatement()
pass
elif la_ == 20:
self.state = 385
self.includeStatement()
pass
elif la_ == 21:
self.state = 386
self.ioDeclarationStatement()
pass
elif la_ == 22:
self.state = 387
self.measureArrowAssignmentStatement()
pass
elif la_ == 23:
self.state = 388
self.oldStyleDeclarationStatement()
pass
elif la_ == 24:
self.state = 389
self.quantumDeclarationStatement()
pass
elif la_ == 25:
self.state = 390
self.resetStatement()
pass
elif la_ == 26:
self.state = 391
self.returnStatement()
pass
elif la_ == 27:
self.state = 392
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(BraketPragmasParser.AnnotationKeyword, 0)
[docs]
def RemainingLineContent(self):
return self.getToken(BraketPragmasParser.RemainingLineContent, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_annotation
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAnnotation"):
return visitor.visitAnnotation(self)
else:
return visitor.visitChildren(self)
[docs]
def annotation(self):
localctx = BraketPragmasParser.AnnotationContext(self, self._ctx, self.state)
self.enterRule(localctx, 62, self.RULE_annotation)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 397
self.match(BraketPragmasParser.AnnotationKeyword)
self.state = 399
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 130:
self.state = 398
self.match(BraketPragmasParser.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(BraketPragmasParser.LBRACE, 0)
[docs]
def RBRACE(self):
return self.getToken(BraketPragmasParser.RBRACE, 0)
[docs]
def statement(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.StatementContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.StatementContext, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_scope
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitScope"):
return visitor.visitScope(self)
else:
return visitor.visitChildren(self)
[docs]
def scope(self):
localctx = BraketPragmasParser.ScopeContext(self, self._ctx, self.state)
self.enterRule(localctx, 64, self.RULE_scope)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 401
self.match(BraketPragmasParser.LBRACE)
self.state = 405
self._errHandler.sync(self)
_la = self._input.LA(1)
while (((_la) & ~0x3F) == 0 and ((1 << _la) & -18304673874182144) != 0) or (
((_la - 64) & ~0x3F) == 0 and ((1 << (_la - 64)) & 143977750197239295) != 0
):
self.state = 402
self.statement()
self.state = 407
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 408
self.match(BraketPragmasParser.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(BraketPragmasParser.PRAGMA, 0)
[docs]
def RemainingLineContent(self):
return self.getToken(BraketPragmasParser.RemainingLineContent, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_pragma
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitPragma"):
return visitor.visitPragma(self)
else:
return visitor.visitChildren(self)
[docs]
def pragma(self):
localctx = BraketPragmasParser.PragmaContext(self, self._ctx, self.state)
self.enterRule(localctx, 66, self.RULE_pragma)
try:
self.enterOuterAlt(localctx, 1)
self.state = 410
self.match(BraketPragmasParser.PRAGMA)
self.state = 411
self.match(BraketPragmasParser.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(BraketPragmasParser.StatementContext, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(BraketPragmasParser.ScopeContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_statementOrScope
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitStatementOrScope"):
return visitor.visitStatementOrScope(self)
else:
return visitor.visitChildren(self)
[docs]
def statementOrScope(self):
localctx = BraketPragmasParser.StatementOrScopeContext(self, self._ctx, self.state)
self.enterRule(localctx, 68, self.RULE_statementOrScope)
try:
self.state = 415
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
44,
45,
46,
47,
49,
50,
51,
52,
53,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
74,
75,
76,
77,
78,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.enterOuterAlt(localctx, 1)
self.state = 413
self.statement()
pass
elif token in [82]:
self.enterOuterAlt(localctx, 2)
self.state = 414
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(BraketPragmasParser.DEFCALGRAMMAR, 0)
[docs]
def StringLiteral(self):
return self.getToken(BraketPragmasParser.StringLiteral, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_calibrationGrammarStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitCalibrationGrammarStatement"):
return visitor.visitCalibrationGrammarStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def calibrationGrammarStatement(self):
localctx = BraketPragmasParser.CalibrationGrammarStatementContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 70, self.RULE_calibrationGrammarStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 417
self.match(BraketPragmasParser.DEFCALGRAMMAR)
self.state = 418
self.match(BraketPragmasParser.StringLiteral)
self.state = 419
self.match(BraketPragmasParser.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(BraketPragmasParser.INCLUDE, 0)
[docs]
def StringLiteral(self):
return self.getToken(BraketPragmasParser.StringLiteral, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_includeStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIncludeStatement"):
return visitor.visitIncludeStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def includeStatement(self):
localctx = BraketPragmasParser.IncludeStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 72, self.RULE_includeStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 421
self.match(BraketPragmasParser.INCLUDE)
self.state = 422
self.match(BraketPragmasParser.StringLiteral)
self.state = 423
self.match(BraketPragmasParser.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(BraketPragmasParser.BREAK, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_breakStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBreakStatement"):
return visitor.visitBreakStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def breakStatement(self):
localctx = BraketPragmasParser.BreakStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 74, self.RULE_breakStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 425
self.match(BraketPragmasParser.BREAK)
self.state = 426
self.match(BraketPragmasParser.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(BraketPragmasParser.CONTINUE, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_continueStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitContinueStatement"):
return visitor.visitContinueStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def continueStatement(self):
localctx = BraketPragmasParser.ContinueStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 76, self.RULE_continueStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 428
self.match(BraketPragmasParser.CONTINUE)
self.state = 429
self.match(BraketPragmasParser.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(BraketPragmasParser.END, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_endStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitEndStatement"):
return visitor.visitEndStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def endStatement(self):
localctx = BraketPragmasParser.EndStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 78, self.RULE_endStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 431
self.match(BraketPragmasParser.END)
self.state = 432
self.match(BraketPragmasParser.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(BraketPragmasParser.FOR, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def Identifier(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.Identifier)
else:
return self.getToken(BraketPragmasParser.Identifier, i)
[docs]
def IN(self):
return self.getToken(BraketPragmasParser.IN, 0)
[docs]
def statementOrScope(self):
return self.getTypedRuleContext(BraketPragmasParser.StatementOrScopeContext, 0)
[docs]
def setExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.SetExpressionContext, 0)
[docs]
def LBRACKET(self):
return self.getToken(BraketPragmasParser.LBRACKET, 0)
[docs]
def rangeExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.RangeExpressionContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_forStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitForStatement"):
return visitor.visitForStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def forStatement(self):
localctx = BraketPragmasParser.ForStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 80, self.RULE_forStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 434
self.match(BraketPragmasParser.FOR)
self.state = 435
self.scalarType()
self.state = 436
self.match(BraketPragmasParser.Identifier)
self.state = 437
self.match(BraketPragmasParser.IN)
self.state = 444
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [82]:
self.state = 438
self.setExpression()
pass
elif token in [80]:
self.state = 439
self.match(BraketPragmasParser.LBRACKET)
self.state = 440
self.rangeExpression()
self.state = 441
self.match(BraketPragmasParser.RBRACKET)
pass
elif token in [116]:
self.state = 443
self.match(BraketPragmasParser.Identifier)
pass
else:
raise NoViableAltException(self)
self.state = 446
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(BraketPragmasParser.IF, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def statementOrScope(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.StatementOrScopeContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.StatementOrScopeContext, i)
[docs]
def ELSE(self):
return self.getToken(BraketPragmasParser.ELSE, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_ifStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIfStatement"):
return visitor.visitIfStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def ifStatement(self):
localctx = BraketPragmasParser.IfStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 82, self.RULE_ifStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 448
self.match(BraketPragmasParser.IF)
self.state = 449
self.match(BraketPragmasParser.LPAREN)
self.state = 450
self.expression(0)
self.state = 451
self.match(BraketPragmasParser.RPAREN)
self.state = 452
localctx.if_body = self.statementOrScope()
self.state = 455
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 27, self._ctx)
if la_ == 1:
self.state = 453
self.match(BraketPragmasParser.ELSE)
self.state = 454
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(BraketPragmasParser.RETURN, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def measureExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.MeasureExpressionContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_returnStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitReturnStatement"):
return visitor.visitReturnStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def returnStatement(self):
localctx = BraketPragmasParser.ReturnStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 84, self.RULE_returnStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 457
self.match(BraketPragmasParser.RETURN)
self.state = 460
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
74,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.state = 458
self.expression(0)
pass
elif token in [77]:
self.state = 459
self.measureExpression()
pass
elif token in [87]:
pass
else:
pass
self.state = 462
self.match(BraketPragmasParser.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(BraketPragmasParser.WHILE, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def statementOrScope(self):
return self.getTypedRuleContext(BraketPragmasParser.StatementOrScopeContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_whileStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitWhileStatement"):
return visitor.visitWhileStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def whileStatement(self):
localctx = BraketPragmasParser.WhileStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_whileStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 464
self.match(BraketPragmasParser.WHILE)
self.state = 465
self.match(BraketPragmasParser.LPAREN)
self.state = 466
self.expression(0)
self.state = 467
self.match(BraketPragmasParser.RPAREN)
self.state = 468
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(BraketPragmasParser.BARRIER, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def gateOperandList(self):
return self.getTypedRuleContext(BraketPragmasParser.GateOperandListContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_barrierStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBarrierStatement"):
return visitor.visitBarrierStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def barrierStatement(self):
localctx = BraketPragmasParser.BarrierStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 88, self.RULE_barrierStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 470
self.match(BraketPragmasParser.BARRIER)
self.state = 472
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 116 or _la == 117:
self.state = 471
self.gateOperandList()
self.state = 474
self.match(BraketPragmasParser.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(BraketPragmasParser.BOX, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(BraketPragmasParser.ScopeContext, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_boxStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitBoxStatement"):
return visitor.visitBoxStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def boxStatement(self):
localctx = BraketPragmasParser.BoxStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 90, self.RULE_boxStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 476
self.match(BraketPragmasParser.BOX)
self.state = 478
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 477
self.designator()
self.state = 480
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(BraketPragmasParser.DELAY, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def gateOperandList(self):
return self.getTypedRuleContext(BraketPragmasParser.GateOperandListContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_delayStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDelayStatement"):
return visitor.visitDelayStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def delayStatement(self):
localctx = BraketPragmasParser.DelayStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 92, self.RULE_delayStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 482
self.match(BraketPragmasParser.DELAY)
self.state = 483
self.designator()
self.state = 485
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 116 or _la == 117:
self.state = 484
self.gateOperandList()
self.state = 487
self.match(BraketPragmasParser.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(BraketPragmasParser.Identifier, 0)
[docs]
def gateOperandList(self):
return self.getTypedRuleContext(BraketPragmasParser.GateOperandListContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def gateModifier(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.GateModifierContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.GateModifierContext, i)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionListContext, 0)
[docs]
def GPHASE(self):
return self.getToken(BraketPragmasParser.GPHASE, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_gateCallStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateCallStatement"):
return visitor.visitGateCallStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def gateCallStatement(self):
localctx = BraketPragmasParser.GateCallStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 94, self.RULE_gateCallStatement)
self._la = 0 # Token type
try:
self.state = 530
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 41, self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 492
self._errHandler.sync(self)
_la = self._input.LA(1)
while ((_la - 69) & ~0x3F) == 0 and ((1 << (_la - 69)) & 15) != 0:
self.state = 489
self.gateModifier()
self.state = 494
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 495
self.match(BraketPragmasParser.Identifier)
self.state = 501
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 84:
self.state = 496
self.match(BraketPragmasParser.LPAREN)
self.state = 498
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 58) & ~0x3F) == 0 and ((1 << (_la - 58)) & 9214576012621317119) != 0:
self.state = 497
self.expressionList()
self.state = 500
self.match(BraketPragmasParser.RPAREN)
self.state = 504
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 503
self.designator()
self.state = 506
self.gateOperandList()
self.state = 507
self.match(BraketPragmasParser.SEMICOLON)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 512
self._errHandler.sync(self)
_la = self._input.LA(1)
while ((_la - 69) & ~0x3F) == 0 and ((1 << (_la - 69)) & 15) != 0:
self.state = 509
self.gateModifier()
self.state = 514
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 515
self.match(BraketPragmasParser.GPHASE)
self.state = 521
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 84:
self.state = 516
self.match(BraketPragmasParser.LPAREN)
self.state = 518
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 58) & ~0x3F) == 0 and ((1 << (_la - 58)) & 9214576012621317119) != 0:
self.state = 517
self.expressionList()
self.state = 520
self.match(BraketPragmasParser.RPAREN)
self.state = 524
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 523
self.designator()
self.state = 527
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 116 or _la == 117:
self.state = 526
self.gateOperandList()
self.state = 529
self.match(BraketPragmasParser.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(BraketPragmasParser.MeasureExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def ARROW(self):
return self.getToken(BraketPragmasParser.ARROW, 0)
[docs]
def indexedIdentifier(self):
return self.getTypedRuleContext(BraketPragmasParser.IndexedIdentifierContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_measureArrowAssignmentStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMeasureArrowAssignmentStatement"):
return visitor.visitMeasureArrowAssignmentStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def measureArrowAssignmentStatement(self):
localctx = BraketPragmasParser.MeasureArrowAssignmentStatementContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 96, self.RULE_measureArrowAssignmentStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 532
self.measureExpression()
self.state = 535
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 91:
self.state = 533
self.match(BraketPragmasParser.ARROW)
self.state = 534
self.indexedIdentifier()
self.state = 537
self.match(BraketPragmasParser.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(BraketPragmasParser.RESET, 0)
[docs]
def gateOperand(self):
return self.getTypedRuleContext(BraketPragmasParser.GateOperandContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_resetStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitResetStatement"):
return visitor.visitResetStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def resetStatement(self):
localctx = BraketPragmasParser.ResetStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_resetStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 539
self.match(BraketPragmasParser.RESET)
self.state = 540
self.gateOperand()
self.state = 541
self.match(BraketPragmasParser.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(BraketPragmasParser.LET, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def EQUALS(self):
return self.getToken(BraketPragmasParser.EQUALS, 0)
[docs]
def aliasExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.AliasExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_aliasDeclarationStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAliasDeclarationStatement"):
return visitor.visitAliasDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def aliasDeclarationStatement(self):
localctx = BraketPragmasParser.AliasDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_aliasDeclarationStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 543
self.match(BraketPragmasParser.LET)
self.state = 544
self.match(BraketPragmasParser.Identifier)
self.state = 545
self.match(BraketPragmasParser.EQUALS)
self.state = 546
self.aliasExpression()
self.state = 547
self.match(BraketPragmasParser.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(BraketPragmasParser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def arrayType(self):
return self.getTypedRuleContext(BraketPragmasParser.ArrayTypeContext, 0)
[docs]
def EQUALS(self):
return self.getToken(BraketPragmasParser.EQUALS, 0)
[docs]
def declarationExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.DeclarationExpressionContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_classicalDeclarationStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitClassicalDeclarationStatement"):
return visitor.visitClassicalDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def classicalDeclarationStatement(self):
localctx = BraketPragmasParser.ClassicalDeclarationStatementContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 102, self.RULE_classicalDeclarationStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 551
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [58, 59, 60, 61, 62, 63, 64, 66, 67]:
self.state = 549
self.scalarType()
pass
elif token in [65]:
self.state = 550
self.arrayType()
pass
else:
raise NoViableAltException(self)
self.state = 553
self.match(BraketPragmasParser.Identifier)
self.state = 556
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 90:
self.state = 554
self.match(BraketPragmasParser.EQUALS)
self.state = 555
self.declarationExpression()
self.state = 558
self.match(BraketPragmasParser.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(BraketPragmasParser.CONST, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def EQUALS(self):
return self.getToken(BraketPragmasParser.EQUALS, 0)
[docs]
def declarationExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.DeclarationExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_constDeclarationStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitConstDeclarationStatement"):
return visitor.visitConstDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def constDeclarationStatement(self):
localctx = BraketPragmasParser.ConstDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 104, self.RULE_constDeclarationStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 560
self.match(BraketPragmasParser.CONST)
self.state = 561
self.scalarType()
self.state = 562
self.match(BraketPragmasParser.Identifier)
self.state = 563
self.match(BraketPragmasParser.EQUALS)
self.state = 564
self.declarationExpression()
self.state = 565
self.match(BraketPragmasParser.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(BraketPragmasParser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def INPUT(self):
return self.getToken(BraketPragmasParser.INPUT, 0)
[docs]
def OUTPUT(self):
return self.getToken(BraketPragmasParser.OUTPUT, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def arrayType(self):
return self.getTypedRuleContext(BraketPragmasParser.ArrayTypeContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_ioDeclarationStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIoDeclarationStatement"):
return visitor.visitIoDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def ioDeclarationStatement(self):
localctx = BraketPragmasParser.IoDeclarationStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_ioDeclarationStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 567
_la = self._input.LA(1)
if not (_la == 51 or _la == 52):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 570
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [58, 59, 60, 61, 62, 63, 64, 66, 67]:
self.state = 568
self.scalarType()
pass
elif token in [65]:
self.state = 569
self.arrayType()
pass
else:
raise NoViableAltException(self)
self.state = 572
self.match(BraketPragmasParser.Identifier)
self.state = 573
self.match(BraketPragmasParser.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(BraketPragmasParser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def CREG(self):
return self.getToken(BraketPragmasParser.CREG, 0)
[docs]
def QREG(self):
return self.getToken(BraketPragmasParser.QREG, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_oldStyleDeclarationStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitOldStyleDeclarationStatement"):
return visitor.visitOldStyleDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def oldStyleDeclarationStatement(self):
localctx = BraketPragmasParser.OldStyleDeclarationStatementContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 108, self.RULE_oldStyleDeclarationStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 575
_la = self._input.LA(1)
if not (_la == 55 or _la == 57):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 576
self.match(BraketPragmasParser.Identifier)
self.state = 578
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 577
self.designator()
self.state = 580
self.match(BraketPragmasParser.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(BraketPragmasParser.QubitTypeContext, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_quantumDeclarationStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitQuantumDeclarationStatement"):
return visitor.visitQuantumDeclarationStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def quantumDeclarationStatement(self):
localctx = BraketPragmasParser.QuantumDeclarationStatementContext(
self, self._ctx, self.state
)
self.enterRule(localctx, 110, self.RULE_quantumDeclarationStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 582
self.qubitType()
self.state = 583
self.match(BraketPragmasParser.Identifier)
self.state = 584
self.match(BraketPragmasParser.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(BraketPragmasParser.DEF, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(BraketPragmasParser.ScopeContext, 0)
[docs]
def argumentDefinitionList(self):
return self.getTypedRuleContext(BraketPragmasParser.ArgumentDefinitionListContext, 0)
[docs]
def returnSignature(self):
return self.getTypedRuleContext(BraketPragmasParser.ReturnSignatureContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_defStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefStatement"):
return visitor.visitDefStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def defStatement(self):
localctx = BraketPragmasParser.DefStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_defStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 586
self.match(BraketPragmasParser.DEF)
self.state = 587
self.match(BraketPragmasParser.Identifier)
self.state = 588
self.match(BraketPragmasParser.LPAREN)
self.state = 590
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 53) & ~0x3F) == 0 and ((1 << (_la - 53)) & 28671) != 0:
self.state = 589
self.argumentDefinitionList()
self.state = 592
self.match(BraketPragmasParser.RPAREN)
self.state = 594
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 91:
self.state = 593
self.returnSignature()
self.state = 596
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(BraketPragmasParser.EXTERN, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def externArgumentList(self):
return self.getTypedRuleContext(BraketPragmasParser.ExternArgumentListContext, 0)
[docs]
def returnSignature(self):
return self.getTypedRuleContext(BraketPragmasParser.ReturnSignatureContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_externStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExternStatement"):
return visitor.visitExternStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def externStatement(self):
localctx = BraketPragmasParser.ExternStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_externStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 598
self.match(BraketPragmasParser.EXTERN)
self.state = 599
self.match(BraketPragmasParser.Identifier)
self.state = 600
self.match(BraketPragmasParser.LPAREN)
self.state = 602
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 53) & ~0x3F) == 0 and ((1 << (_la - 53)) & 28659) != 0:
self.state = 601
self.externArgumentList()
self.state = 604
self.match(BraketPragmasParser.RPAREN)
self.state = 606
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 91:
self.state = 605
self.returnSignature()
self.state = 608
self.match(BraketPragmasParser.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(BraketPragmasParser.GATE, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(BraketPragmasParser.ScopeContext, 0)
[docs]
def identifierList(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.IdentifierListContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.IdentifierListContext, i)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_gateStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateStatement"):
return visitor.visitGateStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def gateStatement(self):
localctx = BraketPragmasParser.GateStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_gateStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 610
self.match(BraketPragmasParser.GATE)
self.state = 611
self.match(BraketPragmasParser.Identifier)
self.state = 617
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 84:
self.state = 612
self.match(BraketPragmasParser.LPAREN)
self.state = 614
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 116:
self.state = 613
localctx.params = self.identifierList()
self.state = 616
self.match(BraketPragmasParser.RPAREN)
self.state = 619
localctx.qubits = self.identifierList()
self.state = 620
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(BraketPragmasParser.IndexedIdentifierContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def EQUALS(self):
return self.getToken(BraketPragmasParser.EQUALS, 0)
[docs]
def CompoundAssignmentOperator(self):
return self.getToken(BraketPragmasParser.CompoundAssignmentOperator, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def measureExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.MeasureExpressionContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_assignmentStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAssignmentStatement"):
return visitor.visitAssignmentStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def assignmentStatement(self):
localctx = BraketPragmasParser.AssignmentStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 118, self.RULE_assignmentStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 622
self.indexedIdentifier()
self.state = 623
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (_la == 90 or _la == 107):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 626
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
74,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.state = 624
self.expression(0)
pass
elif token in [77]:
self.state = 625
self.measureExpression()
pass
else:
raise NoViableAltException(self)
self.state = 628
self.match(BraketPragmasParser.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(BraketPragmasParser.ExpressionContext, 0)
[docs]
def SEMICOLON(self):
return self.getToken(BraketPragmasParser.SEMICOLON, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_expressionStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExpressionStatement"):
return visitor.visitExpressionStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def expressionStatement(self):
localctx = BraketPragmasParser.ExpressionStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 120, self.RULE_expressionStatement)
try:
self.enterOuterAlt(localctx, 1)
self.state = 630
self.expression(0)
self.state = 631
self.match(BraketPragmasParser.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(BraketPragmasParser.DEFCAL, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def defcalArgumentList(self):
return self.getTypedRuleContext(BraketPragmasParser.DefcalArgumentListContext, 0)
[docs]
def LBRACE(self):
return self.getToken(BraketPragmasParser.LBRACE, 0)
[docs]
def RBRACE(self):
return self.getToken(BraketPragmasParser.RBRACE, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def returnSignature(self):
return self.getTypedRuleContext(BraketPragmasParser.ReturnSignatureContext, 0)
[docs]
def argumentDefinitionList(self):
return self.getTypedRuleContext(BraketPragmasParser.ArgumentDefinitionListContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_defcalStatement
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefcalStatement"):
return visitor.visitDefcalStatement(self)
else:
return visitor.visitChildren(self)
[docs]
def defcalStatement(self):
localctx = BraketPragmasParser.DefcalStatementContext(self, self._ctx, self.state)
self.enterRule(localctx, 122, self.RULE_defcalStatement)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 633
self.match(BraketPragmasParser.DEFCAL)
self.state = 634
self.match(BraketPragmasParser.Identifier)
self.state = 640
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 84:
self.state = 635
self.match(BraketPragmasParser.LPAREN)
self.state = 637
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 53) & ~0x3F) == 0 and ((1 << (_la - 53)) & 28671) != 0:
self.state = 636
self.argumentDefinitionList()
self.state = 639
self.match(BraketPragmasParser.RPAREN)
self.state = 642
self.defcalArgumentList()
self.state = 644
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 91:
self.state = 643
self.returnSignature()
self.state = 646
self.match(BraketPragmasParser.LBRACE)
self.state = 650
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 57, self._ctx)
while _alt != 1 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1 + 1:
self.state = 647
self.matchWildcard()
self.state = 652
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 57, self._ctx)
self.state = 653
self.match(BraketPragmasParser.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 BraketPragmasParser.RULE_expression
[docs]
def copyFrom(self, ctx: ParserRuleContext):
super().copyFrom(ctx)
[docs]
class BitwiseXorExpressionContext(ExpressionContext):
def __init__(
self, parser, ctx: ParserRuleContext
): # actually a BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def CARET(self):
return self.getToken(BraketPragmasParser.CARET, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def PLUS(self):
return self.getToken(BraketPragmasParser.PLUS, 0)
[docs]
def MINUS(self):
return self.getToken(BraketPragmasParser.MINUS, 0)
[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 BraketPragmasParser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def DURATIONOF(self):
return self.getToken(BraketPragmasParser.DURATIONOF, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def scope(self):
return self.getTypedRuleContext(BraketPragmasParser.ScopeContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[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 BraketPragmasParser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def ComparisonOperator(self):
return self.getToken(BraketPragmasParser.ComparisonOperator, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def ASTERISK(self):
return self.getToken(BraketPragmasParser.ASTERISK, 0)
[docs]
def SLASH(self):
return self.getToken(BraketPragmasParser.SLASH, 0)
[docs]
def PERCENT(self):
return self.getToken(BraketPragmasParser.PERCENT, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def DOUBLE_PIPE(self):
return self.getToken(BraketPragmasParser.DOUBLE_PIPE, 0)
[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 BraketPragmasParser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def arrayType(self):
return self.getTypedRuleContext(BraketPragmasParser.ArrayTypeContext, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def DOUBLE_ASTERISK(self):
return self.getToken(BraketPragmasParser.DOUBLE_ASTERISK, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def PIPE(self):
return self.getToken(BraketPragmasParser.PIPE, 0)
[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 BraketPragmasParser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionListContext, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def BitshiftOperator(self):
return self.getToken(BraketPragmasParser.BitshiftOperator, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def AMPERSAND(self):
return self.getToken(BraketPragmasParser.AMPERSAND, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def EqualityOperator(self):
return self.getToken(BraketPragmasParser.EqualityOperator, 0)
[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 BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def DOUBLE_AMPERSAND(self):
return self.getToken(BraketPragmasParser.DOUBLE_AMPERSAND, 0)
[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 BraketPragmasParser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def indexOperator(self):
return self.getTypedRuleContext(BraketPragmasParser.IndexOperatorContext, 0)
[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 BraketPragmasParser.ExpressionContext
super().__init__(parser)
self.op = None # Token
self.copyFrom(ctx)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def TILDE(self):
return self.getToken(BraketPragmasParser.TILDE, 0)
[docs]
def EXCLAMATION_POINT(self):
return self.getToken(BraketPragmasParser.EXCLAMATION_POINT, 0)
[docs]
def MINUS(self):
return self.getToken(BraketPragmasParser.MINUS, 0)
[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 BraketPragmasParser.ExpressionContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def BinaryIntegerLiteral(self):
return self.getToken(BraketPragmasParser.BinaryIntegerLiteral, 0)
[docs]
def OctalIntegerLiteral(self):
return self.getToken(BraketPragmasParser.OctalIntegerLiteral, 0)
[docs]
def DecimalIntegerLiteral(self):
return self.getToken(BraketPragmasParser.DecimalIntegerLiteral, 0)
[docs]
def HexIntegerLiteral(self):
return self.getToken(BraketPragmasParser.HexIntegerLiteral, 0)
[docs]
def FloatLiteral(self):
return self.getToken(BraketPragmasParser.FloatLiteral, 0)
[docs]
def ImaginaryLiteral(self):
return self.getToken(BraketPragmasParser.ImaginaryLiteral, 0)
[docs]
def BooleanLiteral(self):
return self.getToken(BraketPragmasParser.BooleanLiteral, 0)
[docs]
def BitstringLiteral(self):
return self.getToken(BraketPragmasParser.BitstringLiteral, 0)
[docs]
def TimingLiteral(self):
return self.getToken(BraketPragmasParser.TimingLiteral, 0)
[docs]
def HardwareQubit(self):
return self.getToken(BraketPragmasParser.HardwareQubit, 0)
[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 = BraketPragmasParser.ExpressionContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 124
self.enterRecursionRule(localctx, 124, self.RULE_expression, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 682
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 60, self._ctx)
if la_ == 1:
localctx = BraketPragmasParser.ParenthesisExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 656
self.match(BraketPragmasParser.LPAREN)
self.state = 657
self.expression(0)
self.state = 658
self.match(BraketPragmasParser.RPAREN)
pass
elif la_ == 2:
localctx = BraketPragmasParser.UnaryExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 660
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (((_la - 94) & ~0x3F) == 0 and ((1 << (_la - 94)) & 3073) != 0):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 661
self.expression(15)
pass
elif la_ == 3:
localctx = BraketPragmasParser.CastExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 664
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [58, 59, 60, 61, 62, 63, 64, 66, 67]:
self.state = 662
self.scalarType()
pass
elif token in [65]:
self.state = 663
self.arrayType()
pass
else:
raise NoViableAltException(self)
self.state = 666
self.match(BraketPragmasParser.LPAREN)
self.state = 667
self.expression(0)
self.state = 668
self.match(BraketPragmasParser.RPAREN)
pass
elif la_ == 4:
localctx = BraketPragmasParser.DurationofExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 670
self.match(BraketPragmasParser.DURATIONOF)
self.state = 671
self.match(BraketPragmasParser.LPAREN)
self.state = 672
self.scope()
self.state = 673
self.match(BraketPragmasParser.RPAREN)
pass
elif la_ == 5:
localctx = BraketPragmasParser.CallExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 675
self.match(BraketPragmasParser.Identifier)
self.state = 676
self.match(BraketPragmasParser.LPAREN)
self.state = 678
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 58) & ~0x3F) == 0 and ((1 << (_la - 58)) & 9214576012621317119) != 0:
self.state = 677
self.expressionList()
self.state = 680
self.match(BraketPragmasParser.RPAREN)
pass
elif la_ == 6:
localctx = BraketPragmasParser.LiteralExpressionContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 681
_la = self._input.LA(1)
if not (((_la - 79) & ~0x3F) == 0 and ((1 << (_la - 79)) & 4393751543809) != 0):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
pass
self._ctx.stop = self._input.LT(-1)
self.state = 721
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 62, 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 = 719
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 61, self._ctx)
if la_ == 1:
localctx = BraketPragmasParser.PowerExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 684
if not self.precpred(self._ctx, 16):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
self.state = 685
localctx.op = self.match(BraketPragmasParser.DOUBLE_ASTERISK)
self.state = 686
self.expression(16)
pass
elif la_ == 2:
localctx = BraketPragmasParser.MultiplicativeExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 687
if not self.precpred(self._ctx, 14):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
self.state = 688
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (((_la - 95) & ~0x3F) == 0 and ((1 << (_la - 95)) & 13) != 0):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 689
self.expression(15)
pass
elif la_ == 3:
localctx = BraketPragmasParser.AdditiveExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 690
if not self.precpred(self._ctx, 13):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
self.state = 691
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not (_la == 92 or _la == 94):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 692
self.expression(14)
pass
elif la_ == 4:
localctx = BraketPragmasParser.BitshiftExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 693
if not self.precpred(self._ctx, 12):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
self.state = 694
localctx.op = self.match(BraketPragmasParser.BitshiftOperator)
self.state = 695
self.expression(13)
pass
elif la_ == 5:
localctx = BraketPragmasParser.ComparisonExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 696
if not self.precpred(self._ctx, 11):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
self.state = 697
localctx.op = self.match(BraketPragmasParser.ComparisonOperator)
self.state = 698
self.expression(12)
pass
elif la_ == 6:
localctx = BraketPragmasParser.EqualityExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 699
if not self.precpred(self._ctx, 10):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
self.state = 700
localctx.op = self.match(BraketPragmasParser.EqualityOperator)
self.state = 701
self.expression(11)
pass
elif la_ == 7:
localctx = BraketPragmasParser.BitwiseAndExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 702
if not self.precpred(self._ctx, 9):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
self.state = 703
localctx.op = self.match(BraketPragmasParser.AMPERSAND)
self.state = 704
self.expression(10)
pass
elif la_ == 8:
localctx = BraketPragmasParser.BitwiseXorExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 705
if not self.precpred(self._ctx, 8):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
self.state = 706
localctx.op = self.match(BraketPragmasParser.CARET)
self.state = 707
self.expression(9)
pass
elif la_ == 9:
localctx = BraketPragmasParser.BitwiseOrExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 708
if not self.precpred(self._ctx, 7):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
self.state = 709
localctx.op = self.match(BraketPragmasParser.PIPE)
self.state = 710
self.expression(8)
pass
elif la_ == 10:
localctx = BraketPragmasParser.LogicalAndExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 711
if not self.precpred(self._ctx, 6):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
self.state = 712
localctx.op = self.match(BraketPragmasParser.DOUBLE_AMPERSAND)
self.state = 713
self.expression(7)
pass
elif la_ == 11:
localctx = BraketPragmasParser.LogicalOrExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 714
if not self.precpred(self._ctx, 5):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
self.state = 715
localctx.op = self.match(BraketPragmasParser.DOUBLE_PIPE)
self.state = 716
self.expression(6)
pass
elif la_ == 12:
localctx = BraketPragmasParser.IndexExpressionContext(
self,
BraketPragmasParser.ExpressionContext(self, _parentctx, _parentState),
)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
self.state = 717
if not self.precpred(self._ctx, 17):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
self.state = 718
self.indexOperator()
pass
self.state = 723
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 62, 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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def DOUBLE_PLUS(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.DOUBLE_PLUS)
else:
return self.getToken(BraketPragmasParser.DOUBLE_PLUS, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_aliasExpression
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitAliasExpression"):
return visitor.visitAliasExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def aliasExpression(self):
localctx = BraketPragmasParser.AliasExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 126, self.RULE_aliasExpression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 724
self.expression(0)
self.state = 729
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 93:
self.state = 725
self.match(BraketPragmasParser.DOUBLE_PLUS)
self.state = 726
self.expression(0)
self.state = 731
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(BraketPragmasParser.ArrayLiteralContext, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def measureExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.MeasureExpressionContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_declarationExpression
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDeclarationExpression"):
return visitor.visitDeclarationExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def declarationExpression(self):
localctx = BraketPragmasParser.DeclarationExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 128, self.RULE_declarationExpression)
try:
self.state = 735
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [82]:
self.enterOuterAlt(localctx, 1)
self.state = 732
self.arrayLiteral()
pass
elif token in [
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
74,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.enterOuterAlt(localctx, 2)
self.state = 733
self.expression(0)
pass
elif token in [77]:
self.enterOuterAlt(localctx, 3)
self.state = 734
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(BraketPragmasParser.MEASURE, 0)
[docs]
def gateOperand(self):
return self.getTypedRuleContext(BraketPragmasParser.GateOperandContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_measureExpression
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitMeasureExpression"):
return visitor.visitMeasureExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def measureExpression(self):
localctx = BraketPragmasParser.MeasureExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 130, self.RULE_measureExpression)
try:
self.enterOuterAlt(localctx, 1)
self.state = 737
self.match(BraketPragmasParser.MEASURE)
self.state = 738
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(BraketPragmasParser.COLON)
else:
return self.getToken(BraketPragmasParser.COLON, i)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_rangeExpression
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitRangeExpression"):
return visitor.visitRangeExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def rangeExpression(self):
localctx = BraketPragmasParser.RangeExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 132, self.RULE_rangeExpression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 741
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 58) & ~0x3F) == 0 and ((1 << (_la - 58)) & 9214576012621317119) != 0:
self.state = 740
self.expression(0)
self.state = 743
self.match(BraketPragmasParser.COLON)
self.state = 745
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((_la - 58) & ~0x3F) == 0 and ((1 << (_la - 58)) & 9214576012621317119) != 0:
self.state = 744
self.expression(0)
self.state = 749
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 86:
self.state = 747
self.match(BraketPragmasParser.COLON)
self.state = 748
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(BraketPragmasParser.LBRACE, 0)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def RBRACE(self):
return self.getToken(BraketPragmasParser.RBRACE, 0)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_setExpression
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitSetExpression"):
return visitor.visitSetExpression(self)
else:
return visitor.visitChildren(self)
[docs]
def setExpression(self):
localctx = BraketPragmasParser.SetExpressionContext(self, self._ctx, self.state)
self.enterRule(localctx, 134, self.RULE_setExpression)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 751
self.match(BraketPragmasParser.LBRACE)
self.state = 752
self.expression(0)
self.state = 757
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 68, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 753
self.match(BraketPragmasParser.COMMA)
self.state = 754
self.expression(0)
self.state = 759
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 68, self._ctx)
self.state = 761
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 760
self.match(BraketPragmasParser.COMMA)
self.state = 763
self.match(BraketPragmasParser.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(BraketPragmasParser.LBRACE, 0)
[docs]
def RBRACE(self):
return self.getToken(BraketPragmasParser.RBRACE, 0)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def arrayLiteral(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.ArrayLiteralContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ArrayLiteralContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_arrayLiteral
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArrayLiteral"):
return visitor.visitArrayLiteral(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayLiteral(self):
localctx = BraketPragmasParser.ArrayLiteralContext(self, self._ctx, self.state)
self.enterRule(localctx, 136, self.RULE_arrayLiteral)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 765
self.match(BraketPragmasParser.LBRACE)
self.state = 768
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
74,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.state = 766
self.expression(0)
pass
elif token in [82]:
self.state = 767
self.arrayLiteral()
pass
else:
raise NoViableAltException(self)
self.state = 777
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 72, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 770
self.match(BraketPragmasParser.COMMA)
self.state = 773
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
74,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.state = 771
self.expression(0)
pass
elif token in [82]:
self.state = 772
self.arrayLiteral()
pass
else:
raise NoViableAltException(self)
self.state = 779
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 72, self._ctx)
self.state = 781
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 780
self.match(BraketPragmasParser.COMMA)
self.state = 783
self.match(BraketPragmasParser.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(BraketPragmasParser.LBRACKET, 0)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def setExpression(self):
return self.getTypedRuleContext(BraketPragmasParser.SetExpressionContext, 0)
[docs]
def expression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def rangeExpression(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.RangeExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.RangeExpressionContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_indexOperator
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIndexOperator"):
return visitor.visitIndexOperator(self)
else:
return visitor.visitChildren(self)
[docs]
def indexOperator(self):
localctx = BraketPragmasParser.IndexOperatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 138, self.RULE_indexOperator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 785
self.match(BraketPragmasParser.LBRACKET)
self.state = 804
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [82]:
self.state = 786
self.setExpression()
pass
elif token in [
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
74,
79,
84,
86,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.state = 789
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 74, self._ctx)
if la_ == 1:
self.state = 787
self.expression(0)
pass
elif la_ == 2:
self.state = 788
self.rangeExpression()
pass
self.state = 798
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 76, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 791
self.match(BraketPragmasParser.COMMA)
self.state = 794
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input, 75, self._ctx)
if la_ == 1:
self.state = 792
self.expression(0)
pass
elif la_ == 2:
self.state = 793
self.rangeExpression()
pass
self.state = 800
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 76, self._ctx)
self.state = 802
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 801
self.match(BraketPragmasParser.COMMA)
pass
else:
raise NoViableAltException(self)
self.state = 806
self.match(BraketPragmasParser.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(BraketPragmasParser.Identifier, 0)
[docs]
def indexOperator(self, i: int = None):
if i is None:
return self.getTypedRuleContexts(BraketPragmasParser.IndexOperatorContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.IndexOperatorContext, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_indexedIdentifier
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIndexedIdentifier"):
return visitor.visitIndexedIdentifier(self)
else:
return visitor.visitChildren(self)
[docs]
def indexedIdentifier(self):
localctx = BraketPragmasParser.IndexedIdentifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 140, self.RULE_indexedIdentifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 808
self.match(BraketPragmasParser.Identifier)
self.state = 812
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la == 80:
self.state = 809
self.indexOperator()
self.state = 814
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(BraketPragmasParser.ARROW, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_returnSignature
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitReturnSignature"):
return visitor.visitReturnSignature(self)
else:
return visitor.visitChildren(self)
[docs]
def returnSignature(self):
localctx = BraketPragmasParser.ReturnSignatureContext(self, self._ctx, self.state)
self.enterRule(localctx, 142, self.RULE_returnSignature)
try:
self.enterOuterAlt(localctx, 1)
self.state = 815
self.match(BraketPragmasParser.ARROW)
self.state = 816
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(BraketPragmasParser.AT, 0)
[docs]
def INV(self):
return self.getToken(BraketPragmasParser.INV, 0)
[docs]
def POW(self):
return self.getToken(BraketPragmasParser.POW, 0)
[docs]
def LPAREN(self):
return self.getToken(BraketPragmasParser.LPAREN, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def RPAREN(self):
return self.getToken(BraketPragmasParser.RPAREN, 0)
[docs]
def CTRL(self):
return self.getToken(BraketPragmasParser.CTRL, 0)
[docs]
def NEGCTRL(self):
return self.getToken(BraketPragmasParser.NEGCTRL, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_gateModifier
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateModifier"):
return visitor.visitGateModifier(self)
else:
return visitor.visitChildren(self)
[docs]
def gateModifier(self):
localctx = BraketPragmasParser.GateModifierContext(self, self._ctx, self.state)
self.enterRule(localctx, 144, self.RULE_gateModifier)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 831
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [69]:
self.state = 818
self.match(BraketPragmasParser.INV)
pass
elif token in [70]:
self.state = 819
self.match(BraketPragmasParser.POW)
self.state = 820
self.match(BraketPragmasParser.LPAREN)
self.state = 821
self.expression(0)
self.state = 822
self.match(BraketPragmasParser.RPAREN)
pass
elif token in [71, 72]:
self.state = 824
_la = self._input.LA(1)
if not (_la == 71 or _la == 72):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 829
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 84:
self.state = 825
self.match(BraketPragmasParser.LPAREN)
self.state = 826
self.expression(0)
self.state = 827
self.match(BraketPragmasParser.RPAREN)
pass
else:
raise NoViableAltException(self)
self.state = 833
self.match(BraketPragmasParser.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(BraketPragmasParser.BIT, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def INT(self):
return self.getToken(BraketPragmasParser.INT, 0)
[docs]
def UINT(self):
return self.getToken(BraketPragmasParser.UINT, 0)
[docs]
def FLOAT(self):
return self.getToken(BraketPragmasParser.FLOAT, 0)
[docs]
def ANGLE(self):
return self.getToken(BraketPragmasParser.ANGLE, 0)
[docs]
def BOOL(self):
return self.getToken(BraketPragmasParser.BOOL, 0)
[docs]
def DURATION(self):
return self.getToken(BraketPragmasParser.DURATION, 0)
[docs]
def STRETCH(self):
return self.getToken(BraketPragmasParser.STRETCH, 0)
[docs]
def COMPLEX(self):
return self.getToken(BraketPragmasParser.COMPLEX, 0)
[docs]
def LBRACKET(self):
return self.getToken(BraketPragmasParser.LBRACKET, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_scalarType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitScalarType"):
return visitor.visitScalarType(self)
else:
return visitor.visitChildren(self)
[docs]
def scalarType(self):
localctx = BraketPragmasParser.ScalarTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 146, self.RULE_scalarType)
self._la = 0 # Token type
try:
self.state = 865
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [59]:
self.enterOuterAlt(localctx, 1)
self.state = 835
self.match(BraketPragmasParser.BIT)
self.state = 837
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 836
self.designator()
pass
elif token in [60]:
self.enterOuterAlt(localctx, 2)
self.state = 839
self.match(BraketPragmasParser.INT)
self.state = 841
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 840
self.designator()
pass
elif token in [61]:
self.enterOuterAlt(localctx, 3)
self.state = 843
self.match(BraketPragmasParser.UINT)
self.state = 845
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 844
self.designator()
pass
elif token in [62]:
self.enterOuterAlt(localctx, 4)
self.state = 847
self.match(BraketPragmasParser.FLOAT)
self.state = 849
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 848
self.designator()
pass
elif token in [63]:
self.enterOuterAlt(localctx, 5)
self.state = 851
self.match(BraketPragmasParser.ANGLE)
self.state = 853
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 852
self.designator()
pass
elif token in [58]:
self.enterOuterAlt(localctx, 6)
self.state = 855
self.match(BraketPragmasParser.BOOL)
pass
elif token in [66]:
self.enterOuterAlt(localctx, 7)
self.state = 856
self.match(BraketPragmasParser.DURATION)
pass
elif token in [67]:
self.enterOuterAlt(localctx, 8)
self.state = 857
self.match(BraketPragmasParser.STRETCH)
pass
elif token in [64]:
self.enterOuterAlt(localctx, 9)
self.state = 858
self.match(BraketPragmasParser.COMPLEX)
self.state = 863
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 859
self.match(BraketPragmasParser.LBRACKET)
self.state = 860
self.scalarType()
self.state = 861
self.match(BraketPragmasParser.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(BraketPragmasParser.QUBIT, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_qubitType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitQubitType"):
return visitor.visitQubitType(self)
else:
return visitor.visitChildren(self)
[docs]
def qubitType(self):
localctx = BraketPragmasParser.QubitTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 148, self.RULE_qubitType)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 867
self.match(BraketPragmasParser.QUBIT)
self.state = 869
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 868
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(BraketPragmasParser.ARRAY, 0)
[docs]
def LBRACKET(self):
return self.getToken(BraketPragmasParser.LBRACKET, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def COMMA(self):
return self.getToken(BraketPragmasParser.COMMA, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionListContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_arrayType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArrayType"):
return visitor.visitArrayType(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayType(self):
localctx = BraketPragmasParser.ArrayTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 150, self.RULE_arrayType)
try:
self.enterOuterAlt(localctx, 1)
self.state = 871
self.match(BraketPragmasParser.ARRAY)
self.state = 872
self.match(BraketPragmasParser.LBRACKET)
self.state = 873
self.scalarType()
self.state = 874
self.match(BraketPragmasParser.COMMA)
self.state = 875
self.expressionList()
self.state = 876
self.match(BraketPragmasParser.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(BraketPragmasParser.ARRAY, 0)
[docs]
def LBRACKET(self):
return self.getToken(BraketPragmasParser.LBRACKET, 0)
[docs]
def scalarType(self):
return self.getTypedRuleContext(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def COMMA(self):
return self.getToken(BraketPragmasParser.COMMA, 0)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def CONST(self):
return self.getToken(BraketPragmasParser.CONST, 0)
[docs]
def MUTABLE(self):
return self.getToken(BraketPragmasParser.MUTABLE, 0)
[docs]
def expressionList(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionListContext, 0)
[docs]
def DIM(self):
return self.getToken(BraketPragmasParser.DIM, 0)
[docs]
def EQUALS(self):
return self.getToken(BraketPragmasParser.EQUALS, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_arrayReferenceType
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArrayReferenceType"):
return visitor.visitArrayReferenceType(self)
else:
return visitor.visitChildren(self)
[docs]
def arrayReferenceType(self):
localctx = BraketPragmasParser.ArrayReferenceTypeContext(self, self._ctx, self.state)
self.enterRule(localctx, 152, self.RULE_arrayReferenceType)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 878
_la = self._input.LA(1)
if not (_la == 53 or _la == 54):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 879
self.match(BraketPragmasParser.ARRAY)
self.state = 880
self.match(BraketPragmasParser.LBRACKET)
self.state = 881
self.scalarType()
self.state = 882
self.match(BraketPragmasParser.COMMA)
self.state = 887
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
74,
79,
84,
94,
104,
105,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
]:
self.state = 883
self.expressionList()
pass
elif token in [73]:
self.state = 884
self.match(BraketPragmasParser.DIM)
self.state = 885
self.match(BraketPragmasParser.EQUALS)
self.state = 886
self.expression(0)
pass
else:
raise NoViableAltException(self)
self.state = 889
self.match(BraketPragmasParser.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(BraketPragmasParser.LBRACKET, 0)
[docs]
def expression(self):
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, 0)
[docs]
def RBRACKET(self):
return self.getToken(BraketPragmasParser.RBRACKET, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_designator
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDesignator"):
return visitor.visitDesignator(self)
else:
return visitor.visitChildren(self)
[docs]
def designator(self):
localctx = BraketPragmasParser.DesignatorContext(self, self._ctx, self.state)
self.enterRule(localctx, 154, self.RULE_designator)
try:
self.enterOuterAlt(localctx, 1)
self.state = 891
self.match(BraketPragmasParser.LBRACKET)
self.state = 892
self.expression(0)
self.state = 893
self.match(BraketPragmasParser.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(BraketPragmasParser.IndexedIdentifierContext, 0)
[docs]
def HardwareQubit(self):
return self.getToken(BraketPragmasParser.HardwareQubit, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_gateOperand
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateOperand"):
return visitor.visitGateOperand(self)
else:
return visitor.visitChildren(self)
[docs]
def gateOperand(self):
localctx = BraketPragmasParser.GateOperandContext(self, self._ctx, self.state)
self.enterRule(localctx, 156, self.RULE_gateOperand)
try:
self.state = 897
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [116]:
self.enterOuterAlt(localctx, 1)
self.state = 895
self.indexedIdentifier()
pass
elif token in [117]:
self.enterOuterAlt(localctx, 2)
self.state = 896
self.match(BraketPragmasParser.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(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def arrayReferenceType(self):
return self.getTypedRuleContext(BraketPragmasParser.ArrayReferenceTypeContext, 0)
[docs]
def CREG(self):
return self.getToken(BraketPragmasParser.CREG, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_externArgument
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExternArgument"):
return visitor.visitExternArgument(self)
else:
return visitor.visitChildren(self)
[docs]
def externArgument(self):
localctx = BraketPragmasParser.ExternArgumentContext(self, self._ctx, self.state)
self.enterRule(localctx, 158, self.RULE_externArgument)
self._la = 0 # Token type
try:
self.state = 905
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [58, 59, 60, 61, 62, 63, 64, 66, 67]:
self.enterOuterAlt(localctx, 1)
self.state = 899
self.scalarType()
pass
elif token in [53, 54]:
self.enterOuterAlt(localctx, 2)
self.state = 900
self.arrayReferenceType()
pass
elif token in [57]:
self.enterOuterAlt(localctx, 3)
self.state = 901
self.match(BraketPragmasParser.CREG)
self.state = 903
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 902
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(BraketPragmasParser.HardwareQubit, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_defcalArgument
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefcalArgument"):
return visitor.visitDefcalArgument(self)
else:
return visitor.visitChildren(self)
[docs]
def defcalArgument(self):
localctx = BraketPragmasParser.DefcalArgumentContext(self, self._ctx, self.state)
self.enterRule(localctx, 160, self.RULE_defcalArgument)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 907
_la = self._input.LA(1)
if not (_la == 116 or _la == 117):
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(BraketPragmasParser.ScalarTypeContext, 0)
[docs]
def Identifier(self):
return self.getToken(BraketPragmasParser.Identifier, 0)
[docs]
def qubitType(self):
return self.getTypedRuleContext(BraketPragmasParser.QubitTypeContext, 0)
[docs]
def CREG(self):
return self.getToken(BraketPragmasParser.CREG, 0)
[docs]
def QREG(self):
return self.getToken(BraketPragmasParser.QREG, 0)
[docs]
def designator(self):
return self.getTypedRuleContext(BraketPragmasParser.DesignatorContext, 0)
[docs]
def arrayReferenceType(self):
return self.getTypedRuleContext(BraketPragmasParser.ArrayReferenceTypeContext, 0)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_argumentDefinition
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArgumentDefinition"):
return visitor.visitArgumentDefinition(self)
else:
return visitor.visitChildren(self)
[docs]
def argumentDefinition(self):
localctx = BraketPragmasParser.ArgumentDefinitionContext(self, self._ctx, self.state)
self.enterRule(localctx, 162, self.RULE_argumentDefinition)
self._la = 0 # Token type
try:
self.state = 923
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [58, 59, 60, 61, 62, 63, 64, 66, 67]:
self.enterOuterAlt(localctx, 1)
self.state = 909
self.scalarType()
self.state = 910
self.match(BraketPragmasParser.Identifier)
pass
elif token in [56]:
self.enterOuterAlt(localctx, 2)
self.state = 912
self.qubitType()
self.state = 913
self.match(BraketPragmasParser.Identifier)
pass
elif token in [55, 57]:
self.enterOuterAlt(localctx, 3)
self.state = 915
_la = self._input.LA(1)
if not (_la == 55 or _la == 57):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 916
self.match(BraketPragmasParser.Identifier)
self.state = 918
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 80:
self.state = 917
self.designator()
pass
elif token in [53, 54]:
self.enterOuterAlt(localctx, 4)
self.state = 920
self.arrayReferenceType()
self.state = 921
self.match(BraketPragmasParser.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(BraketPragmasParser.ArgumentDefinitionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ArgumentDefinitionContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_argumentDefinitionList
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitArgumentDefinitionList"):
return visitor.visitArgumentDefinitionList(self)
else:
return visitor.visitChildren(self)
[docs]
def argumentDefinitionList(self):
localctx = BraketPragmasParser.ArgumentDefinitionListContext(self, self._ctx, self.state)
self.enterRule(localctx, 164, self.RULE_argumentDefinitionList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 925
self.argumentDefinition()
self.state = 930
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 96, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 926
self.match(BraketPragmasParser.COMMA)
self.state = 927
self.argumentDefinition()
self.state = 932
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 96, self._ctx)
self.state = 934
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 933
self.match(BraketPragmasParser.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(BraketPragmasParser.ExpressionContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExpressionContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_expressionList
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExpressionList"):
return visitor.visitExpressionList(self)
else:
return visitor.visitChildren(self)
[docs]
def expressionList(self):
localctx = BraketPragmasParser.ExpressionListContext(self, self._ctx, self.state)
self.enterRule(localctx, 166, self.RULE_expressionList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 936
self.expression(0)
self.state = 941
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 98, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 937
self.match(BraketPragmasParser.COMMA)
self.state = 938
self.expression(0)
self.state = 943
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 98, self._ctx)
self.state = 945
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 944
self.match(BraketPragmasParser.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(BraketPragmasParser.DefcalArgumentContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.DefcalArgumentContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_defcalArgumentList
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitDefcalArgumentList"):
return visitor.visitDefcalArgumentList(self)
else:
return visitor.visitChildren(self)
[docs]
def defcalArgumentList(self):
localctx = BraketPragmasParser.DefcalArgumentListContext(self, self._ctx, self.state)
self.enterRule(localctx, 168, self.RULE_defcalArgumentList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 947
self.defcalArgument()
self.state = 952
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 100, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 948
self.match(BraketPragmasParser.COMMA)
self.state = 949
self.defcalArgument()
self.state = 954
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 100, self._ctx)
self.state = 956
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 955
self.match(BraketPragmasParser.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(BraketPragmasParser.Identifier)
else:
return self.getToken(BraketPragmasParser.Identifier, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_identifierList
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitIdentifierList"):
return visitor.visitIdentifierList(self)
else:
return visitor.visitChildren(self)
[docs]
def identifierList(self):
localctx = BraketPragmasParser.IdentifierListContext(self, self._ctx, self.state)
self.enterRule(localctx, 170, self.RULE_identifierList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 958
self.match(BraketPragmasParser.Identifier)
self.state = 963
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 102, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 959
self.match(BraketPragmasParser.COMMA)
self.state = 960
self.match(BraketPragmasParser.Identifier)
self.state = 965
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 102, self._ctx)
self.state = 967
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 966
self.match(BraketPragmasParser.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(BraketPragmasParser.GateOperandContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.GateOperandContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_gateOperandList
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitGateOperandList"):
return visitor.visitGateOperandList(self)
else:
return visitor.visitChildren(self)
[docs]
def gateOperandList(self):
localctx = BraketPragmasParser.GateOperandListContext(self, self._ctx, self.state)
self.enterRule(localctx, 172, self.RULE_gateOperandList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 969
self.gateOperand()
self.state = 974
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 104, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 970
self.match(BraketPragmasParser.COMMA)
self.state = 971
self.gateOperand()
self.state = 976
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 104, self._ctx)
self.state = 978
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 977
self.match(BraketPragmasParser.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(BraketPragmasParser.ExternArgumentContext)
else:
return self.getTypedRuleContext(BraketPragmasParser.ExternArgumentContext, i)
[docs]
def COMMA(self, i: int = None):
if i is None:
return self.getTokens(BraketPragmasParser.COMMA)
else:
return self.getToken(BraketPragmasParser.COMMA, i)
[docs]
def getRuleIndex(self):
return BraketPragmasParser.RULE_externArgumentList
[docs]
def accept(self, visitor: ParseTreeVisitor):
if hasattr(visitor, "visitExternArgumentList"):
return visitor.visitExternArgumentList(self)
else:
return visitor.visitChildren(self)
[docs]
def externArgumentList(self):
localctx = BraketPragmasParser.ExternArgumentListContext(self, self._ctx, self.state)
self.enterRule(localctx, 174, self.RULE_externArgumentList)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 980
self.externArgument()
self.state = 985
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 106, self._ctx)
while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 981
self.match(BraketPragmasParser.COMMA)
self.state = 982
self.externArgument()
self.state = 987
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input, 106, self._ctx)
self.state = 989
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la == 89:
self.state = 988
self.match(BraketPragmasParser.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[62] = 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)