OpenMD 3.2
Molecular Dynamics in the Open
Loading...
Searching...
No Matches
OMDParser.cpp
1
2#include "antlr4-runtime.h"
3#include "utils/StringUtils.hpp"
4#include "omdParser/FilenameObserver.hpp"
5
6
7// Generated from OMD.g4 by ANTLR 4.13.2
8
9
10#include "OMDListener.h"
11#include "OMDVisitor.h"
12
13#include "OMDParser.h"
14
15
16using namespace antlrcpp;
17
18using namespace antlr4;
19
20namespace {
21
22struct OMDParserStaticData final {
23 OMDParserStaticData(std::vector<std::string> ruleNames,
24 std::vector<std::string> literalNames,
25 std::vector<std::string> symbolicNames)
26 : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
27 symbolicNames(std::move(symbolicNames)),
28 vocabulary(this->literalNames, this->symbolicNames) {}
29
30 OMDParserStaticData(const OMDParserStaticData&) = delete;
31 OMDParserStaticData(OMDParserStaticData&&) = delete;
32 OMDParserStaticData& operator=(const OMDParserStaticData&) = delete;
33 OMDParserStaticData& operator=(OMDParserStaticData&&) = delete;
34
35 std::vector<antlr4::dfa::DFA> decisionToDFA;
36 antlr4::atn::PredictionContextCache sharedContextCache;
37 const std::vector<std::string> ruleNames;
38 const std::vector<std::string> literalNames;
39 const std::vector<std::string> symbolicNames;
40 const antlr4::dfa::Vocabulary vocabulary;
41 antlr4::atn::SerializedATNView serializedATN;
42 std::unique_ptr<antlr4::atn::ATN> atn;
43};
44
45::antlr4::internal::OnceFlag omdParserOnceFlag;
46#if ANTLR4_USE_THREAD_LOCAL_CACHE
47static thread_local
48#endif
49std::unique_ptr<OMDParserStaticData> omdParserStaticData = nullptr;
50
51void omdParserInitialize() {
52#if ANTLR4_USE_THREAD_LOCAL_CACHE
53 if (omdParserStaticData != nullptr) {
54 return;
55 }
56#else
57 assert(omdParserStaticData == nullptr);
58#endif
59 auto staticData = std::make_unique<OMDParserStaticData>(
60 std::vector<std::string>{
61 "omdfile", "statement", "assignment", "constant", "componentblock",
62 "zconstraintblock", "restraintblock", "flucqblock", "rnemdblock",
63 "lightblock", "velocityfieldblock", "minimizerblock", "moleculeblock",
64 "moleculestatement", "atomblock", "atomstatement", "bondblock", "bondstatement",
65 "bendblock", "bendstatement", "torsionblock", "torsionstatement",
66 "inversionblock", "inversionstatement", "rigidbodyblock", "rigidbodystatement",
67 "cutoffgroupblock", "cutoffgroupstatement", "nodesblock", "nodesstatement",
68 "fragmentblock", "fragmentstatement", "constraintblock", "constraintstatement",
69 "sequencestring", "doubleNumberTuple", "inttuple", "intConst", "doubleNumber",
70 "floatConst", "vectorConst"
71 },
72 std::vector<std::string>{
73 "", "'true'", "'false'", "'component'", "'molecule'", "'zconstraint'",
74 "'restraint'", "'atom'", "'bond'", "'bend'", "'torsion'", "'inversion'",
75 "'rigidBody'", "'cutoffGroup'", "'constraint'", "'distance'", "'fragment'",
76 "'sequence'", "'members'", "'center'", "'satellites'", "'position'",
77 "'orientation'", "'flucQ'", "'RNEMD'", "'light'", "'velocityField'",
78 "'minimizer'", "'Fixed'", "'Harmonic'", "'Cubic'", "'Quartic'", "'Polynomial'",
79 "'Morse'", "'GhostBend'", "'UreyBradley'", "'Cosine'", "'GhostTorsion'",
80 "'Charmm'", "'Opls'", "'Trappe'", "'AmberImproper'", "'ImproperCosine'",
81 "'CentralAtomHeight'", "'Dreiding'", "'charge'", "'nodes'", "'='",
82 "':'", "','", "'\\u003F'", "';'", "'.'", "'('", "')'", "'['", "']'",
83 "'{'", "'}'"
84 },
85 std::vector<std::string>{
86 "", "TRUE", "FALSE", "COMPONENT", "MOLECULE", "ZCONSTRAINT", "RESTRAINT",
87 "ATOM", "BOND", "BEND", "TORSION", "INVERSION", "RIGIDBODY", "CUTOFFGROUP",
88 "CONSTRAINT", "DISTANCE", "FRAGMENT", "SEQUENCE", "MEMBERS", "CENTER",
89 "SATELLITES", "POSITION", "ORIENTATION", "FLUCQ", "RNEMD", "LIGHT",
90 "VELOCITYFIELD", "MINIMIZER", "FIXED", "HARMONIC", "CUBIC", "QUARTIC",
91 "POLYNOMIAL", "MORSE", "GHOSTBEND", "UREYBRADLEY", "COSINE", "GHOSTTORSION",
92 "CHARMM", "OPLS", "TRAPPE", "AMBERIMPROPER", "IMPROPERCOSINE", "CENTRALATOMHEIGHT",
93 "DREIDING", "CHARGE", "NODES", "ASSIGNEQUAL", "COLON", "COMMA", "QUESTIONMARK",
94 "SEMICOLON", "DOT", "LPAREN", "RPAREN", "LBRACKET", "RBRACKET", "LCURLY",
95 "RCURLY", "NUM_LONG", "NUM_INT", "NUM_FLOAT", "NUM_DOUBLE", "CharLiteral",
96 "StringLiteral", "ID", "Whitespace", "Newline", "LineContinuation",
97 "Comment", "CPPComment", "PREPROC_DIRECTIVE"
98 }
99 );
100 static const int32_t serializedATNSegment[] = {
101 4,1,71,668,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,
102 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,
103 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,
104 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,
105 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,
106 35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,1,0,5,0,84,8,0,10,
107 0,12,0,87,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,
108 102,8,1,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,116,8,3,1,
109 4,1,4,1,4,5,4,121,8,4,10,4,12,4,124,9,4,1,4,1,4,1,5,1,5,1,5,5,5,131,8,
110 5,10,5,12,5,134,9,5,1,5,1,5,1,6,1,6,1,6,5,6,141,8,6,10,6,12,6,144,9,6,
111 1,6,1,6,1,7,1,7,1,7,5,7,151,8,7,10,7,12,7,154,9,7,1,7,1,7,1,8,1,8,1,8,
112 5,8,161,8,8,10,8,12,8,164,9,8,1,8,1,8,1,9,1,9,1,9,5,9,171,8,9,10,9,12,
113 9,174,9,9,1,9,1,9,1,10,1,10,1,10,5,10,181,8,10,10,10,12,10,184,9,10,1,
114 10,1,10,1,11,1,11,1,11,5,11,191,8,11,10,11,12,11,194,9,11,1,11,1,11,1,
115 12,1,12,1,12,5,12,201,8,12,10,12,12,12,204,9,12,1,12,1,12,1,13,1,13,1,
116 13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,218,8,13,1,14,1,14,1,14,1,
117 14,1,14,1,14,5,14,226,8,14,10,14,12,14,229,9,14,1,14,1,14,1,15,1,15,1,
118 15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,
119 15,1,15,1,15,3,15,252,8,15,1,16,1,16,1,16,1,16,1,16,3,16,259,8,16,1,16,
120 1,16,5,16,263,8,16,10,16,12,16,266,9,16,1,16,1,16,1,17,1,17,1,17,1,17,
121 1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,
122 1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,
123 1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,313,8,17,
124 1,18,1,18,1,18,1,18,1,18,3,18,320,8,18,1,18,1,18,5,18,324,8,18,10,18,
125 12,18,327,9,18,1,18,1,18,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,
126 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,
127 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,
128 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,380,
129 8,19,1,20,1,20,1,20,1,20,1,20,3,20,387,8,20,1,20,1,20,5,20,391,8,20,10,
130 20,12,20,394,9,20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,
131 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,
132 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,
133 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,
134 21,1,21,1,21,1,21,1,21,3,21,453,8,21,1,22,1,22,1,22,1,22,1,22,3,22,460,
135 8,22,1,22,1,22,5,22,464,8,22,10,22,12,22,467,9,22,1,22,1,22,1,23,1,23,
136 1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
137 1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
138 1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,
139 514,8,23,1,24,1,24,1,24,1,24,1,24,1,24,5,24,522,8,24,10,24,12,24,525,
140 9,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,536,8,25,1,26,
141 1,26,1,26,1,26,1,26,3,26,543,8,26,1,26,1,26,5,26,547,8,26,10,26,12,26,
142 550,9,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,27,3,27,561,8,27,1,
143 28,1,28,1,28,1,28,1,28,3,28,568,8,28,1,28,1,28,5,28,572,8,28,10,28,12,
144 28,575,9,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,586,8,29,
145 1,30,1,30,1,30,5,30,591,8,30,10,30,12,30,594,9,30,1,30,1,30,1,31,1,31,
146 1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,608,8,31,1,32,1,32,1,32,
147 1,32,1,32,3,32,615,8,32,1,32,1,32,5,32,619,8,32,10,32,12,32,622,9,32,
148 1,32,1,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,3,33,633,8,33,1,34,1,34,
149 1,34,1,34,1,34,1,35,1,35,1,35,5,35,643,8,35,10,35,12,35,646,9,35,1,36,
150 1,36,1,36,5,36,651,8,36,10,36,12,36,654,9,36,1,37,1,37,1,38,1,38,3,38,
151 660,8,38,1,39,1,39,1,40,1,40,1,40,1,40,1,40,0,0,41,0,2,4,6,8,10,12,14,
152 16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,
153 62,64,66,68,70,72,74,76,78,80,0,2,1,0,59,60,1,0,61,62,728,0,85,1,0,0,
154 0,2,101,1,0,0,0,4,103,1,0,0,0,6,115,1,0,0,0,8,117,1,0,0,0,10,127,1,0,
155 0,0,12,137,1,0,0,0,14,147,1,0,0,0,16,157,1,0,0,0,18,167,1,0,0,0,20,177,
156 1,0,0,0,22,187,1,0,0,0,24,197,1,0,0,0,26,217,1,0,0,0,28,219,1,0,0,0,30,
157 251,1,0,0,0,32,253,1,0,0,0,34,312,1,0,0,0,36,314,1,0,0,0,38,379,1,0,0,
158 0,40,381,1,0,0,0,42,452,1,0,0,0,44,454,1,0,0,0,46,513,1,0,0,0,48,515,
159 1,0,0,0,50,535,1,0,0,0,52,537,1,0,0,0,54,560,1,0,0,0,56,562,1,0,0,0,58,
160 585,1,0,0,0,60,587,1,0,0,0,62,607,1,0,0,0,64,609,1,0,0,0,66,632,1,0,0,
161 0,68,634,1,0,0,0,70,639,1,0,0,0,72,647,1,0,0,0,74,655,1,0,0,0,76,659,
162 1,0,0,0,78,661,1,0,0,0,80,663,1,0,0,0,82,84,3,2,1,0,83,82,1,0,0,0,84,
163 87,1,0,0,0,85,83,1,0,0,0,85,86,1,0,0,0,86,88,1,0,0,0,87,85,1,0,0,0,88,
164 89,5,0,0,1,89,1,1,0,0,0,90,102,3,4,2,0,91,102,3,8,4,0,92,102,3,24,12,
165 0,93,102,3,60,30,0,94,102,3,10,5,0,95,102,3,12,6,0,96,102,3,14,7,0,97,
166 102,3,16,8,0,98,102,3,18,9,0,99,102,3,20,10,0,100,102,3,22,11,0,101,90,
167 1,0,0,0,101,91,1,0,0,0,101,92,1,0,0,0,101,93,1,0,0,0,101,94,1,0,0,0,101,
168 95,1,0,0,0,101,96,1,0,0,0,101,97,1,0,0,0,101,98,1,0,0,0,101,99,1,0,0,
169 0,101,100,1,0,0,0,102,3,1,0,0,0,103,104,5,65,0,0,104,105,5,47,0,0,105,
170 106,3,6,3,0,106,107,5,51,0,0,107,5,1,0,0,0,108,116,3,74,37,0,109,116,
171 3,78,39,0,110,116,3,80,40,0,111,116,5,1,0,0,112,116,5,2,0,0,113,116,5,
172 65,0,0,114,116,5,64,0,0,115,108,1,0,0,0,115,109,1,0,0,0,115,110,1,0,0,
173 0,115,111,1,0,0,0,115,112,1,0,0,0,115,113,1,0,0,0,115,114,1,0,0,0,116,
174 7,1,0,0,0,117,118,5,3,0,0,118,122,5,57,0,0,119,121,3,4,2,0,120,119,1,
175 0,0,0,121,124,1,0,0,0,122,120,1,0,0,0,122,123,1,0,0,0,123,125,1,0,0,0,
176 124,122,1,0,0,0,125,126,5,58,0,0,126,9,1,0,0,0,127,128,5,5,0,0,128,132,
177 5,57,0,0,129,131,3,4,2,0,130,129,1,0,0,0,131,134,1,0,0,0,132,130,1,0,
178 0,0,132,133,1,0,0,0,133,135,1,0,0,0,134,132,1,0,0,0,135,136,5,58,0,0,
179 136,11,1,0,0,0,137,138,5,6,0,0,138,142,5,57,0,0,139,141,3,4,2,0,140,139,
180 1,0,0,0,141,144,1,0,0,0,142,140,1,0,0,0,142,143,1,0,0,0,143,145,1,0,0,
181 0,144,142,1,0,0,0,145,146,5,58,0,0,146,13,1,0,0,0,147,148,5,23,0,0,148,
182 152,5,57,0,0,149,151,3,4,2,0,150,149,1,0,0,0,151,154,1,0,0,0,152,150,
183 1,0,0,0,152,153,1,0,0,0,153,155,1,0,0,0,154,152,1,0,0,0,155,156,5,58,
184 0,0,156,15,1,0,0,0,157,158,5,24,0,0,158,162,5,57,0,0,159,161,3,4,2,0,
185 160,159,1,0,0,0,161,164,1,0,0,0,162,160,1,0,0,0,162,163,1,0,0,0,163,165,
186 1,0,0,0,164,162,1,0,0,0,165,166,5,58,0,0,166,17,1,0,0,0,167,168,5,25,
187 0,0,168,172,5,57,0,0,169,171,3,4,2,0,170,169,1,0,0,0,171,174,1,0,0,0,
188 172,170,1,0,0,0,172,173,1,0,0,0,173,175,1,0,0,0,174,172,1,0,0,0,175,176,
189 5,58,0,0,176,19,1,0,0,0,177,178,5,26,0,0,178,182,5,57,0,0,179,181,3,4,
190 2,0,180,179,1,0,0,0,181,184,1,0,0,0,182,180,1,0,0,0,182,183,1,0,0,0,183,
191 185,1,0,0,0,184,182,1,0,0,0,185,186,5,58,0,0,186,21,1,0,0,0,187,188,5,
192 27,0,0,188,192,5,57,0,0,189,191,3,4,2,0,190,189,1,0,0,0,191,194,1,0,0,
193 0,192,190,1,0,0,0,192,193,1,0,0,0,193,195,1,0,0,0,194,192,1,0,0,0,195,
194 196,5,58,0,0,196,23,1,0,0,0,197,198,5,4,0,0,198,202,5,57,0,0,199,201,
195 3,26,13,0,200,199,1,0,0,0,201,204,1,0,0,0,202,200,1,0,0,0,202,203,1,0,
196 0,0,203,205,1,0,0,0,204,202,1,0,0,0,205,206,5,58,0,0,206,25,1,0,0,0,207,
197 218,3,4,2,0,208,218,3,28,14,0,209,218,3,32,16,0,210,218,3,36,18,0,211,
198 218,3,40,20,0,212,218,3,44,22,0,213,218,3,48,24,0,214,218,3,52,26,0,215,
199 218,3,64,32,0,216,218,3,68,34,0,217,207,1,0,0,0,217,208,1,0,0,0,217,209,
200 1,0,0,0,217,210,1,0,0,0,217,211,1,0,0,0,217,212,1,0,0,0,217,213,1,0,0,
201 0,217,214,1,0,0,0,217,215,1,0,0,0,217,216,1,0,0,0,218,27,1,0,0,0,219,
202 220,5,7,0,0,220,221,5,55,0,0,221,222,3,74,37,0,222,223,5,56,0,0,223,227,
203 5,57,0,0,224,226,3,30,15,0,225,224,1,0,0,0,226,229,1,0,0,0,227,225,1,
204 0,0,0,227,228,1,0,0,0,228,230,1,0,0,0,229,227,1,0,0,0,230,231,5,58,0,
205 0,231,29,1,0,0,0,232,252,3,4,2,0,233,234,5,21,0,0,234,235,5,53,0,0,235,
206 236,3,70,35,0,236,237,5,54,0,0,237,238,5,51,0,0,238,252,1,0,0,0,239,240,
207 5,22,0,0,240,241,5,53,0,0,241,242,3,70,35,0,242,243,5,54,0,0,243,244,
208 5,51,0,0,244,252,1,0,0,0,245,246,5,45,0,0,246,247,5,53,0,0,247,248,3,
209 78,39,0,248,249,5,54,0,0,249,250,5,51,0,0,250,252,1,0,0,0,251,232,1,0,
210 0,0,251,233,1,0,0,0,251,239,1,0,0,0,251,245,1,0,0,0,252,31,1,0,0,0,253,
211 258,5,8,0,0,254,255,5,55,0,0,255,256,3,74,37,0,256,257,5,56,0,0,257,259,
212 1,0,0,0,258,254,1,0,0,0,258,259,1,0,0,0,259,260,1,0,0,0,260,264,5,57,
213 0,0,261,263,3,34,17,0,262,261,1,0,0,0,263,266,1,0,0,0,264,262,1,0,0,0,
214 264,265,1,0,0,0,265,267,1,0,0,0,266,264,1,0,0,0,267,268,5,58,0,0,268,
215 33,1,0,0,0,269,313,3,4,2,0,270,271,5,18,0,0,271,272,5,53,0,0,272,273,
216 3,72,36,0,273,274,5,54,0,0,274,275,5,51,0,0,275,313,1,0,0,0,276,277,5,
217 28,0,0,277,278,5,53,0,0,278,279,3,78,39,0,279,280,5,54,0,0,280,281,5,
218 51,0,0,281,313,1,0,0,0,282,283,5,29,0,0,283,284,5,53,0,0,284,285,3,70,
219 35,0,285,286,5,54,0,0,286,287,5,51,0,0,287,313,1,0,0,0,288,289,5,30,0,
220 0,289,290,5,53,0,0,290,291,3,70,35,0,291,292,5,54,0,0,292,293,5,51,0,
221 0,293,313,1,0,0,0,294,295,5,31,0,0,295,296,5,53,0,0,296,297,3,70,35,0,
222 297,298,5,54,0,0,298,299,5,51,0,0,299,313,1,0,0,0,300,301,5,32,0,0,301,
223 302,5,53,0,0,302,303,3,70,35,0,303,304,5,54,0,0,304,305,5,51,0,0,305,
224 313,1,0,0,0,306,307,5,33,0,0,307,308,5,53,0,0,308,309,3,70,35,0,309,310,
225 5,54,0,0,310,311,5,51,0,0,311,313,1,0,0,0,312,269,1,0,0,0,312,270,1,0,
226 0,0,312,276,1,0,0,0,312,282,1,0,0,0,312,288,1,0,0,0,312,294,1,0,0,0,312,
227 300,1,0,0,0,312,306,1,0,0,0,313,35,1,0,0,0,314,319,5,9,0,0,315,316,5,
228 55,0,0,316,317,3,74,37,0,317,318,5,56,0,0,318,320,1,0,0,0,319,315,1,0,
229 0,0,319,320,1,0,0,0,320,321,1,0,0,0,321,325,5,57,0,0,322,324,3,38,19,
230 0,323,322,1,0,0,0,324,327,1,0,0,0,325,323,1,0,0,0,325,326,1,0,0,0,326,
231 328,1,0,0,0,327,325,1,0,0,0,328,329,5,58,0,0,329,37,1,0,0,0,330,380,3,
232 4,2,0,331,332,5,18,0,0,332,333,5,53,0,0,333,334,3,72,36,0,334,335,5,54,
233 0,0,335,336,5,51,0,0,336,380,1,0,0,0,337,338,5,29,0,0,338,339,5,53,0,
234 0,339,340,3,70,35,0,340,341,5,54,0,0,341,342,5,51,0,0,342,380,1,0,0,0,
235 343,344,5,34,0,0,344,345,5,53,0,0,345,346,3,70,35,0,346,347,5,54,0,0,
236 347,348,5,51,0,0,348,380,1,0,0,0,349,350,5,35,0,0,350,351,5,53,0,0,351,
237 352,3,70,35,0,352,353,5,54,0,0,353,354,5,51,0,0,354,380,1,0,0,0,355,356,
238 5,30,0,0,356,357,5,53,0,0,357,358,3,70,35,0,358,359,5,54,0,0,359,360,
239 5,51,0,0,360,380,1,0,0,0,361,362,5,31,0,0,362,363,5,53,0,0,363,364,3,
240 70,35,0,364,365,5,54,0,0,365,366,5,51,0,0,366,380,1,0,0,0,367,368,5,32,
241 0,0,368,369,5,53,0,0,369,370,3,70,35,0,370,371,5,54,0,0,371,372,5,51,
242 0,0,372,380,1,0,0,0,373,374,5,36,0,0,374,375,5,53,0,0,375,376,3,70,35,
243 0,376,377,5,54,0,0,377,378,5,51,0,0,378,380,1,0,0,0,379,330,1,0,0,0,379,
244 331,1,0,0,0,379,337,1,0,0,0,379,343,1,0,0,0,379,349,1,0,0,0,379,355,1,
245 0,0,0,379,361,1,0,0,0,379,367,1,0,0,0,379,373,1,0,0,0,380,39,1,0,0,0,
246 381,386,5,10,0,0,382,383,5,55,0,0,383,384,3,74,37,0,384,385,5,56,0,0,
247 385,387,1,0,0,0,386,382,1,0,0,0,386,387,1,0,0,0,387,388,1,0,0,0,388,392,
248 5,57,0,0,389,391,3,42,21,0,390,389,1,0,0,0,391,394,1,0,0,0,392,390,1,
249 0,0,0,392,393,1,0,0,0,393,395,1,0,0,0,394,392,1,0,0,0,395,396,5,58,0,
250 0,396,41,1,0,0,0,397,453,3,4,2,0,398,399,5,18,0,0,399,400,5,53,0,0,400,
251 401,3,72,36,0,401,402,5,54,0,0,402,403,5,51,0,0,403,453,1,0,0,0,404,405,
252 5,37,0,0,405,406,5,53,0,0,406,407,3,70,35,0,407,408,5,54,0,0,408,409,
253 5,51,0,0,409,453,1,0,0,0,410,411,5,30,0,0,411,412,5,53,0,0,412,413,3,
254 70,35,0,413,414,5,54,0,0,414,415,5,51,0,0,415,453,1,0,0,0,416,417,5,31,
255 0,0,417,418,5,53,0,0,418,419,3,70,35,0,419,420,5,54,0,0,420,421,5,51,
256 0,0,421,453,1,0,0,0,422,423,5,32,0,0,423,424,5,53,0,0,424,425,3,70,35,
257 0,425,426,5,54,0,0,426,427,5,51,0,0,427,453,1,0,0,0,428,429,5,38,0,0,
258 429,430,5,53,0,0,430,431,3,70,35,0,431,432,5,54,0,0,432,433,5,51,0,0,
259 433,453,1,0,0,0,434,435,5,39,0,0,435,436,5,53,0,0,436,437,3,70,35,0,437,
260 438,5,54,0,0,438,439,5,51,0,0,439,453,1,0,0,0,440,441,5,40,0,0,441,442,
261 5,53,0,0,442,443,3,70,35,0,443,444,5,54,0,0,444,445,5,51,0,0,445,453,
262 1,0,0,0,446,447,5,29,0,0,447,448,5,53,0,0,448,449,3,70,35,0,449,450,5,
263 54,0,0,450,451,5,51,0,0,451,453,1,0,0,0,452,397,1,0,0,0,452,398,1,0,0,
264 0,452,404,1,0,0,0,452,410,1,0,0,0,452,416,1,0,0,0,452,422,1,0,0,0,452,
265 428,1,0,0,0,452,434,1,0,0,0,452,440,1,0,0,0,452,446,1,0,0,0,453,43,1,
266 0,0,0,454,459,5,11,0,0,455,456,5,55,0,0,456,457,3,74,37,0,457,458,5,56,
267 0,0,458,460,1,0,0,0,459,455,1,0,0,0,459,460,1,0,0,0,460,461,1,0,0,0,461,
268 465,5,57,0,0,462,464,3,46,23,0,463,462,1,0,0,0,464,467,1,0,0,0,465,463,
269 1,0,0,0,465,466,1,0,0,0,466,468,1,0,0,0,467,465,1,0,0,0,468,469,5,58,
270 0,0,469,45,1,0,0,0,470,514,3,4,2,0,471,472,5,19,0,0,472,473,5,53,0,0,
271 473,474,3,74,37,0,474,475,5,54,0,0,475,476,5,51,0,0,476,514,1,0,0,0,477,
272 478,5,20,0,0,478,479,5,53,0,0,479,480,3,72,36,0,480,481,5,54,0,0,481,
273 482,5,51,0,0,482,514,1,0,0,0,483,484,5,41,0,0,484,485,5,53,0,0,485,486,
274 3,70,35,0,486,487,5,54,0,0,487,488,5,51,0,0,488,514,1,0,0,0,489,490,5,
275 42,0,0,490,491,5,53,0,0,491,492,3,70,35,0,492,493,5,54,0,0,493,494,5,
276 51,0,0,494,514,1,0,0,0,495,496,5,29,0,0,496,497,5,53,0,0,497,498,3,70,
277 35,0,498,499,5,54,0,0,499,500,5,51,0,0,500,514,1,0,0,0,501,502,5,43,0,
278 0,502,503,5,53,0,0,503,504,3,70,35,0,504,505,5,54,0,0,505,506,5,51,0,
279 0,506,514,1,0,0,0,507,508,5,44,0,0,508,509,5,53,0,0,509,510,3,70,35,0,
280 510,511,5,54,0,0,511,512,5,51,0,0,512,514,1,0,0,0,513,470,1,0,0,0,513,
281 471,1,0,0,0,513,477,1,0,0,0,513,483,1,0,0,0,513,489,1,0,0,0,513,495,1,
282 0,0,0,513,501,1,0,0,0,513,507,1,0,0,0,514,47,1,0,0,0,515,516,5,12,0,0,
283 516,517,5,55,0,0,517,518,3,74,37,0,518,519,5,56,0,0,519,523,5,57,0,0,
284 520,522,3,50,25,0,521,520,1,0,0,0,522,525,1,0,0,0,523,521,1,0,0,0,523,
285 524,1,0,0,0,524,526,1,0,0,0,525,523,1,0,0,0,526,527,5,58,0,0,527,49,1,
286 0,0,0,528,536,3,4,2,0,529,530,5,18,0,0,530,531,5,53,0,0,531,532,3,72,
287 36,0,532,533,5,54,0,0,533,534,5,51,0,0,534,536,1,0,0,0,535,528,1,0,0,
288 0,535,529,1,0,0,0,536,51,1,0,0,0,537,542,5,13,0,0,538,539,5,55,0,0,539,
289 540,3,74,37,0,540,541,5,56,0,0,541,543,1,0,0,0,542,538,1,0,0,0,542,543,
290 1,0,0,0,543,544,1,0,0,0,544,548,5,57,0,0,545,547,3,54,27,0,546,545,1,
291 0,0,0,547,550,1,0,0,0,548,546,1,0,0,0,548,549,1,0,0,0,549,551,1,0,0,0,
292 550,548,1,0,0,0,551,552,5,58,0,0,552,53,1,0,0,0,553,561,3,4,2,0,554,555,
293 5,18,0,0,555,556,5,53,0,0,556,557,3,72,36,0,557,558,5,54,0,0,558,559,
294 5,51,0,0,559,561,1,0,0,0,560,553,1,0,0,0,560,554,1,0,0,0,561,55,1,0,0,
295 0,562,567,5,46,0,0,563,564,5,55,0,0,564,565,3,74,37,0,565,566,5,56,0,
296 0,566,568,1,0,0,0,567,563,1,0,0,0,567,568,1,0,0,0,568,569,1,0,0,0,569,
297 573,5,57,0,0,570,572,3,58,29,0,571,570,1,0,0,0,572,575,1,0,0,0,573,571,
298 1,0,0,0,573,574,1,0,0,0,574,576,1,0,0,0,575,573,1,0,0,0,576,577,5,58,
299 0,0,577,57,1,0,0,0,578,586,3,4,2,0,579,580,5,18,0,0,580,581,5,53,0,0,
300 581,582,3,72,36,0,582,583,5,54,0,0,583,584,5,51,0,0,584,586,1,0,0,0,585,
301 578,1,0,0,0,585,579,1,0,0,0,586,59,1,0,0,0,587,588,5,16,0,0,588,592,5,
302 57,0,0,589,591,3,62,31,0,590,589,1,0,0,0,591,594,1,0,0,0,592,590,1,0,
303 0,0,592,593,1,0,0,0,593,595,1,0,0,0,594,592,1,0,0,0,595,596,5,58,0,0,
304 596,61,1,0,0,0,597,608,3,4,2,0,598,608,3,28,14,0,599,608,3,32,16,0,600,
305 608,3,36,18,0,601,608,3,40,20,0,602,608,3,44,22,0,603,608,3,48,24,0,604,
306 608,3,52,26,0,605,608,3,64,32,0,606,608,3,56,28,0,607,597,1,0,0,0,607,
307 598,1,0,0,0,607,599,1,0,0,0,607,600,1,0,0,0,607,601,1,0,0,0,607,602,1,
308 0,0,0,607,603,1,0,0,0,607,604,1,0,0,0,607,605,1,0,0,0,607,606,1,0,0,0,
309 608,63,1,0,0,0,609,614,5,14,0,0,610,611,5,55,0,0,611,612,3,74,37,0,612,
310 613,5,56,0,0,613,615,1,0,0,0,614,610,1,0,0,0,614,615,1,0,0,0,615,616,
311 1,0,0,0,616,620,5,57,0,0,617,619,3,66,33,0,618,617,1,0,0,0,619,622,1,
312 0,0,0,620,618,1,0,0,0,620,621,1,0,0,0,621,623,1,0,0,0,622,620,1,0,0,0,
313 623,624,5,58,0,0,624,65,1,0,0,0,625,633,3,4,2,0,626,627,5,18,0,0,627,
314 628,5,53,0,0,628,629,3,72,36,0,629,630,5,54,0,0,630,631,5,51,0,0,631,
315 633,1,0,0,0,632,625,1,0,0,0,632,626,1,0,0,0,633,67,1,0,0,0,634,635,5,
316 17,0,0,635,636,5,47,0,0,636,637,3,6,3,0,637,638,5,51,0,0,638,69,1,0,0,
317 0,639,644,3,76,38,0,640,641,5,49,0,0,641,643,3,76,38,0,642,640,1,0,0,
318 0,643,646,1,0,0,0,644,642,1,0,0,0,644,645,1,0,0,0,645,71,1,0,0,0,646,
319 644,1,0,0,0,647,652,3,74,37,0,648,649,5,49,0,0,649,651,3,74,37,0,650,
320 648,1,0,0,0,651,654,1,0,0,0,652,650,1,0,0,0,652,653,1,0,0,0,653,73,1,
321 0,0,0,654,652,1,0,0,0,655,656,7,0,0,0,656,75,1,0,0,0,657,660,3,74,37,
322 0,658,660,3,78,39,0,659,657,1,0,0,0,659,658,1,0,0,0,660,77,1,0,0,0,661,
323 662,7,1,0,0,662,79,1,0,0,0,663,664,5,53,0,0,664,665,3,70,35,0,665,666,
324 5,54,0,0,666,81,1,0,0,0,43,85,101,115,122,132,142,152,162,172,182,192,
325 202,217,227,251,258,264,312,319,325,379,386,392,452,459,465,513,523,535,
326 542,548,560,567,573,585,592,607,614,620,632,644,652,659
327 };
328 staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
329
330 antlr4::atn::ATNDeserializer deserializer;
331 staticData->atn = deserializer.deserialize(staticData->serializedATN);
332
333 const size_t count = staticData->atn->getNumberOfDecisions();
334 staticData->decisionToDFA.reserve(count);
335 for (size_t i = 0; i < count; i++) {
336 staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
337 }
338 omdParserStaticData = std::move(staticData);
339}
340
341}
342
343OMDParser::OMDParser(TokenStream *input) : OMDParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
344
345OMDParser::OMDParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
346 OMDParser::initialize();
347 _interpreter = new atn::ParserATNSimulator(this, *omdParserStaticData->atn, omdParserStaticData->decisionToDFA, omdParserStaticData->sharedContextCache, options);
348}
349
350OMDParser::~OMDParser() {
351 delete _interpreter;
352}
353
354const atn::ATN& OMDParser::getATN() const {
355 return *omdParserStaticData->atn;
356}
357
358std::string OMDParser::getGrammarFileName() const {
359 return "OMD.g4";
360}
361
362const std::vector<std::string>& OMDParser::getRuleNames() const {
363 return omdParserStaticData->ruleNames;
364}
365
366const dfa::Vocabulary& OMDParser::getVocabulary() const {
367 return omdParserStaticData->vocabulary;
368}
369
370antlr4::atn::SerializedATNView OMDParser::getSerializedATN() const {
371 return omdParserStaticData->serializedATN;
372}
373
374
375//----------------- OmdfileContext ------------------------------------------------------------------
376
377OMDParser::OmdfileContext::OmdfileContext(ParserRuleContext *parent, size_t invokingState)
378 : ParserRuleContext(parent, invokingState) {
379}
380
381tree::TerminalNode* OMDParser::OmdfileContext::EOF() {
382 return getToken(OMDParser::EOF, 0);
383}
384
385std::vector<OMDParser::StatementContext *> OMDParser::OmdfileContext::statement() {
386 return getRuleContexts<OMDParser::StatementContext>();
387}
388
389OMDParser::StatementContext* OMDParser::OmdfileContext::statement(size_t i) {
390 return getRuleContext<OMDParser::StatementContext>(i);
391}
392
393
394size_t OMDParser::OmdfileContext::getRuleIndex() const {
395 return OMDParser::RuleOmdfile;
396}
397
398void OMDParser::OmdfileContext::enterRule(tree::ParseTreeListener *listener) {
399 auto parserListener = dynamic_cast<OMDListener *>(listener);
400 if (parserListener != nullptr)
401 parserListener->enterOmdfile(this);
402}
403
404void OMDParser::OmdfileContext::exitRule(tree::ParseTreeListener *listener) {
405 auto parserListener = dynamic_cast<OMDListener *>(listener);
406 if (parserListener != nullptr)
407 parserListener->exitOmdfile(this);
408}
409
410
411std::any OMDParser::OmdfileContext::accept(tree::ParseTreeVisitor *visitor) {
412 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
413 return parserVisitor->visitOmdfile(this);
414 else
415 return visitor->visitChildren(this);
416}
417
418OMDParser::OmdfileContext* OMDParser::omdfile() {
419 OmdfileContext *_localctx = _tracker.createInstance<OmdfileContext>(_ctx, getState());
420 enterRule(_localctx, 0, OMDParser::RuleOmdfile);
421 size_t _la = 0;
422
423#if __cplusplus > 201703L
424 auto onExit = finally([=, this] {
425#else
426 auto onExit = finally([=] {
427#endif
428 exitRule();
429 });
430 try {
431 enterOuterAlt(_localctx, 1);
432 setState(85);
433 _errHandler->sync(this);
434 _la = _input->LA(1);
435 while (((((_la - 3) & ~ 0x3fULL) == 0) &&
436 ((1ULL << (_la - 3)) & 4611686018459901967) != 0)) {
437 setState(82);
438 statement();
439 setState(87);
440 _errHandler->sync(this);
441 _la = _input->LA(1);
442 }
443 setState(88);
444 match(OMDParser::EOF);
445
446 }
447 catch (RecognitionException &e) {
448 _errHandler->reportError(this, e);
449 _localctx->exception = std::current_exception();
450 _errHandler->recover(this, _localctx->exception);
451 }
452
453 return _localctx;
454}
455
456//----------------- StatementContext ------------------------------------------------------------------
457
458OMDParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
459 : ParserRuleContext(parent, invokingState) {
460}
461
462OMDParser::AssignmentContext* OMDParser::StatementContext::assignment() {
463 return getRuleContext<OMDParser::AssignmentContext>(0);
464}
465
466OMDParser::ComponentblockContext* OMDParser::StatementContext::componentblock() {
467 return getRuleContext<OMDParser::ComponentblockContext>(0);
468}
469
470OMDParser::MoleculeblockContext* OMDParser::StatementContext::moleculeblock() {
471 return getRuleContext<OMDParser::MoleculeblockContext>(0);
472}
473
474OMDParser::FragmentblockContext* OMDParser::StatementContext::fragmentblock() {
475 return getRuleContext<OMDParser::FragmentblockContext>(0);
476}
477
478OMDParser::ZconstraintblockContext* OMDParser::StatementContext::zconstraintblock() {
479 return getRuleContext<OMDParser::ZconstraintblockContext>(0);
480}
481
482OMDParser::RestraintblockContext* OMDParser::StatementContext::restraintblock() {
483 return getRuleContext<OMDParser::RestraintblockContext>(0);
484}
485
486OMDParser::FlucqblockContext* OMDParser::StatementContext::flucqblock() {
487 return getRuleContext<OMDParser::FlucqblockContext>(0);
488}
489
490OMDParser::RnemdblockContext* OMDParser::StatementContext::rnemdblock() {
491 return getRuleContext<OMDParser::RnemdblockContext>(0);
492}
493
494OMDParser::LightblockContext* OMDParser::StatementContext::lightblock() {
495 return getRuleContext<OMDParser::LightblockContext>(0);
496}
497
498OMDParser::VelocityfieldblockContext* OMDParser::StatementContext::velocityfieldblock() {
499 return getRuleContext<OMDParser::VelocityfieldblockContext>(0);
500}
501
502OMDParser::MinimizerblockContext* OMDParser::StatementContext::minimizerblock() {
503 return getRuleContext<OMDParser::MinimizerblockContext>(0);
504}
505
506
507size_t OMDParser::StatementContext::getRuleIndex() const {
508 return OMDParser::RuleStatement;
509}
510
511void OMDParser::StatementContext::enterRule(tree::ParseTreeListener *listener) {
512 auto parserListener = dynamic_cast<OMDListener *>(listener);
513 if (parserListener != nullptr)
514 parserListener->enterStatement(this);
515}
516
517void OMDParser::StatementContext::exitRule(tree::ParseTreeListener *listener) {
518 auto parserListener = dynamic_cast<OMDListener *>(listener);
519 if (parserListener != nullptr)
520 parserListener->exitStatement(this);
521}
522
523
524std::any OMDParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
525 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
526 return parserVisitor->visitStatement(this);
527 else
528 return visitor->visitChildren(this);
529}
530
531OMDParser::StatementContext* OMDParser::statement() {
532 StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
533 enterRule(_localctx, 2, OMDParser::RuleStatement);
534
535#if __cplusplus > 201703L
536 auto onExit = finally([=, this] {
537#else
538 auto onExit = finally([=] {
539#endif
540 exitRule();
541 });
542 try {
543 setState(101);
544 _errHandler->sync(this);
545 switch (_input->LA(1)) {
546 case OMDParser::ID: {
547 enterOuterAlt(_localctx, 1);
548 setState(90);
549 assignment();
550 break;
551 }
552
553 case OMDParser::COMPONENT: {
554 enterOuterAlt(_localctx, 2);
555 setState(91);
556 componentblock();
557 break;
558 }
559
560 case OMDParser::MOLECULE: {
561 enterOuterAlt(_localctx, 3);
562 setState(92);
563 moleculeblock();
564 break;
565 }
566
567 case OMDParser::FRAGMENT: {
568 enterOuterAlt(_localctx, 4);
569 setState(93);
570 fragmentblock();
571 break;
572 }
573
574 case OMDParser::ZCONSTRAINT: {
575 enterOuterAlt(_localctx, 5);
576 setState(94);
577 zconstraintblock();
578 break;
579 }
580
581 case OMDParser::RESTRAINT: {
582 enterOuterAlt(_localctx, 6);
583 setState(95);
584 restraintblock();
585 break;
586 }
587
588 case OMDParser::FLUCQ: {
589 enterOuterAlt(_localctx, 7);
590 setState(96);
591 flucqblock();
592 break;
593 }
594
595 case OMDParser::RNEMD: {
596 enterOuterAlt(_localctx, 8);
597 setState(97);
598 rnemdblock();
599 break;
600 }
601
602 case OMDParser::LIGHT: {
603 enterOuterAlt(_localctx, 9);
604 setState(98);
605 lightblock();
606 break;
607 }
608
609 case OMDParser::VELOCITYFIELD: {
610 enterOuterAlt(_localctx, 10);
611 setState(99);
612 velocityfieldblock();
613 break;
614 }
615
616 case OMDParser::MINIMIZER: {
617 enterOuterAlt(_localctx, 11);
618 setState(100);
619 minimizerblock();
620 break;
621 }
622
623 default:
624 throw NoViableAltException(this);
625 }
626
627 }
628 catch (RecognitionException &e) {
629 _errHandler->reportError(this, e);
630 _localctx->exception = std::current_exception();
631 _errHandler->recover(this, _localctx->exception);
632 }
633
634 return _localctx;
635}
636
637//----------------- AssignmentContext ------------------------------------------------------------------
638
639OMDParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState)
640 : ParserRuleContext(parent, invokingState) {
641}
642
643tree::TerminalNode* OMDParser::AssignmentContext::ID() {
644 return getToken(OMDParser::ID, 0);
645}
646
647tree::TerminalNode* OMDParser::AssignmentContext::ASSIGNEQUAL() {
648 return getToken(OMDParser::ASSIGNEQUAL, 0);
649}
650
651OMDParser::ConstantContext* OMDParser::AssignmentContext::constant() {
652 return getRuleContext<OMDParser::ConstantContext>(0);
653}
654
655tree::TerminalNode* OMDParser::AssignmentContext::SEMICOLON() {
656 return getToken(OMDParser::SEMICOLON, 0);
657}
658
659
660size_t OMDParser::AssignmentContext::getRuleIndex() const {
661 return OMDParser::RuleAssignment;
662}
663
664void OMDParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) {
665 auto parserListener = dynamic_cast<OMDListener *>(listener);
666 if (parserListener != nullptr)
667 parserListener->enterAssignment(this);
668}
669
670void OMDParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) {
671 auto parserListener = dynamic_cast<OMDListener *>(listener);
672 if (parserListener != nullptr)
673 parserListener->exitAssignment(this);
674}
675
676
677std::any OMDParser::AssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
678 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
679 return parserVisitor->visitAssignment(this);
680 else
681 return visitor->visitChildren(this);
682}
683
684OMDParser::AssignmentContext* OMDParser::assignment() {
685 AssignmentContext *_localctx = _tracker.createInstance<AssignmentContext>(_ctx, getState());
686 enterRule(_localctx, 4, OMDParser::RuleAssignment);
687
688#if __cplusplus > 201703L
689 auto onExit = finally([=, this] {
690#else
691 auto onExit = finally([=] {
692#endif
693 exitRule();
694 });
695 try {
696 enterOuterAlt(_localctx, 1);
697 setState(103);
698 match(OMDParser::ID);
699 setState(104);
700 match(OMDParser::ASSIGNEQUAL);
701 setState(105);
702 constant();
703 setState(106);
704 match(OMDParser::SEMICOLON);
705
706 }
707 catch (RecognitionException &e) {
708 _errHandler->reportError(this, e);
709 _localctx->exception = std::current_exception();
710 _errHandler->recover(this, _localctx->exception);
711 }
712
713 return _localctx;
714}
715
716//----------------- ConstantContext ------------------------------------------------------------------
717
718OMDParser::ConstantContext::ConstantContext(ParserRuleContext *parent, size_t invokingState)
719 : ParserRuleContext(parent, invokingState) {
720}
721
722OMDParser::IntConstContext* OMDParser::ConstantContext::intConst() {
723 return getRuleContext<OMDParser::IntConstContext>(0);
724}
725
726OMDParser::FloatConstContext* OMDParser::ConstantContext::floatConst() {
727 return getRuleContext<OMDParser::FloatConstContext>(0);
728}
729
730OMDParser::VectorConstContext* OMDParser::ConstantContext::vectorConst() {
731 return getRuleContext<OMDParser::VectorConstContext>(0);
732}
733
734tree::TerminalNode* OMDParser::ConstantContext::TRUE() {
735 return getToken(OMDParser::TRUE, 0);
736}
737
738tree::TerminalNode* OMDParser::ConstantContext::FALSE() {
739 return getToken(OMDParser::FALSE, 0);
740}
741
742tree::TerminalNode* OMDParser::ConstantContext::ID() {
743 return getToken(OMDParser::ID, 0);
744}
745
746tree::TerminalNode* OMDParser::ConstantContext::StringLiteral() {
747 return getToken(OMDParser::StringLiteral, 0);
748}
749
750
751size_t OMDParser::ConstantContext::getRuleIndex() const {
752 return OMDParser::RuleConstant;
753}
754
755void OMDParser::ConstantContext::enterRule(tree::ParseTreeListener *listener) {
756 auto parserListener = dynamic_cast<OMDListener *>(listener);
757 if (parserListener != nullptr)
758 parserListener->enterConstant(this);
759}
760
761void OMDParser::ConstantContext::exitRule(tree::ParseTreeListener *listener) {
762 auto parserListener = dynamic_cast<OMDListener *>(listener);
763 if (parserListener != nullptr)
764 parserListener->exitConstant(this);
765}
766
767
768std::any OMDParser::ConstantContext::accept(tree::ParseTreeVisitor *visitor) {
769 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
770 return parserVisitor->visitConstant(this);
771 else
772 return visitor->visitChildren(this);
773}
774
775OMDParser::ConstantContext* OMDParser::constant() {
776 ConstantContext *_localctx = _tracker.createInstance<ConstantContext>(_ctx, getState());
777 enterRule(_localctx, 6, OMDParser::RuleConstant);
778
779#if __cplusplus > 201703L
780 auto onExit = finally([=, this] {
781#else
782 auto onExit = finally([=] {
783#endif
784 exitRule();
785 });
786 try {
787 setState(115);
788 _errHandler->sync(this);
789 switch (_input->LA(1)) {
790 case OMDParser::NUM_LONG:
791 case OMDParser::NUM_INT: {
792 enterOuterAlt(_localctx, 1);
793 setState(108);
794 intConst();
795 break;
796 }
797
798 case OMDParser::NUM_FLOAT:
799 case OMDParser::NUM_DOUBLE: {
800 enterOuterAlt(_localctx, 2);
801 setState(109);
802 floatConst();
803 break;
804 }
805
806 case OMDParser::LPAREN: {
807 enterOuterAlt(_localctx, 3);
808 setState(110);
809 vectorConst();
810 break;
811 }
812
813 case OMDParser::TRUE: {
814 enterOuterAlt(_localctx, 4);
815 setState(111);
816 match(OMDParser::TRUE);
817 break;
818 }
819
820 case OMDParser::FALSE: {
821 enterOuterAlt(_localctx, 5);
822 setState(112);
823 match(OMDParser::FALSE);
824 break;
825 }
826
827 case OMDParser::ID: {
828 enterOuterAlt(_localctx, 6);
829 setState(113);
830 match(OMDParser::ID);
831 break;
832 }
833
834 case OMDParser::StringLiteral: {
835 enterOuterAlt(_localctx, 7);
836 setState(114);
837 match(OMDParser::StringLiteral);
838 break;
839 }
840
841 default:
842 throw NoViableAltException(this);
843 }
844
845 }
846 catch (RecognitionException &e) {
847 _errHandler->reportError(this, e);
848 _localctx->exception = std::current_exception();
849 _errHandler->recover(this, _localctx->exception);
850 }
851
852 return _localctx;
853}
854
855//----------------- ComponentblockContext ------------------------------------------------------------------
856
857OMDParser::ComponentblockContext::ComponentblockContext(ParserRuleContext *parent, size_t invokingState)
858 : ParserRuleContext(parent, invokingState) {
859}
860
861tree::TerminalNode* OMDParser::ComponentblockContext::COMPONENT() {
862 return getToken(OMDParser::COMPONENT, 0);
863}
864
865tree::TerminalNode* OMDParser::ComponentblockContext::LCURLY() {
866 return getToken(OMDParser::LCURLY, 0);
867}
868
869tree::TerminalNode* OMDParser::ComponentblockContext::RCURLY() {
870 return getToken(OMDParser::RCURLY, 0);
871}
872
873std::vector<OMDParser::AssignmentContext *> OMDParser::ComponentblockContext::assignment() {
874 return getRuleContexts<OMDParser::AssignmentContext>();
875}
876
877OMDParser::AssignmentContext* OMDParser::ComponentblockContext::assignment(size_t i) {
878 return getRuleContext<OMDParser::AssignmentContext>(i);
879}
880
881
882size_t OMDParser::ComponentblockContext::getRuleIndex() const {
883 return OMDParser::RuleComponentblock;
884}
885
886void OMDParser::ComponentblockContext::enterRule(tree::ParseTreeListener *listener) {
887 auto parserListener = dynamic_cast<OMDListener *>(listener);
888 if (parserListener != nullptr)
889 parserListener->enterComponentblock(this);
890}
891
892void OMDParser::ComponentblockContext::exitRule(tree::ParseTreeListener *listener) {
893 auto parserListener = dynamic_cast<OMDListener *>(listener);
894 if (parserListener != nullptr)
895 parserListener->exitComponentblock(this);
896}
897
898
899std::any OMDParser::ComponentblockContext::accept(tree::ParseTreeVisitor *visitor) {
900 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
901 return parserVisitor->visitComponentblock(this);
902 else
903 return visitor->visitChildren(this);
904}
905
906OMDParser::ComponentblockContext* OMDParser::componentblock() {
907 ComponentblockContext *_localctx = _tracker.createInstance<ComponentblockContext>(_ctx, getState());
908 enterRule(_localctx, 8, OMDParser::RuleComponentblock);
909 size_t _la = 0;
910
911#if __cplusplus > 201703L
912 auto onExit = finally([=, this] {
913#else
914 auto onExit = finally([=] {
915#endif
916 exitRule();
917 });
918 try {
919 enterOuterAlt(_localctx, 1);
920 setState(117);
921 match(OMDParser::COMPONENT);
922 setState(118);
923 match(OMDParser::LCURLY);
924 setState(122);
925 _errHandler->sync(this);
926 _la = _input->LA(1);
927 while (_la == OMDParser::ID) {
928 setState(119);
929 assignment();
930 setState(124);
931 _errHandler->sync(this);
932 _la = _input->LA(1);
933 }
934 setState(125);
935 match(OMDParser::RCURLY);
936
937 }
938 catch (RecognitionException &e) {
939 _errHandler->reportError(this, e);
940 _localctx->exception = std::current_exception();
941 _errHandler->recover(this, _localctx->exception);
942 }
943
944 return _localctx;
945}
946
947//----------------- ZconstraintblockContext ------------------------------------------------------------------
948
949OMDParser::ZconstraintblockContext::ZconstraintblockContext(ParserRuleContext *parent, size_t invokingState)
950 : ParserRuleContext(parent, invokingState) {
951}
952
953tree::TerminalNode* OMDParser::ZconstraintblockContext::ZCONSTRAINT() {
954 return getToken(OMDParser::ZCONSTRAINT, 0);
955}
956
957tree::TerminalNode* OMDParser::ZconstraintblockContext::LCURLY() {
958 return getToken(OMDParser::LCURLY, 0);
959}
960
961tree::TerminalNode* OMDParser::ZconstraintblockContext::RCURLY() {
962 return getToken(OMDParser::RCURLY, 0);
963}
964
965std::vector<OMDParser::AssignmentContext *> OMDParser::ZconstraintblockContext::assignment() {
966 return getRuleContexts<OMDParser::AssignmentContext>();
967}
968
969OMDParser::AssignmentContext* OMDParser::ZconstraintblockContext::assignment(size_t i) {
970 return getRuleContext<OMDParser::AssignmentContext>(i);
971}
972
973
974size_t OMDParser::ZconstraintblockContext::getRuleIndex() const {
975 return OMDParser::RuleZconstraintblock;
976}
977
978void OMDParser::ZconstraintblockContext::enterRule(tree::ParseTreeListener *listener) {
979 auto parserListener = dynamic_cast<OMDListener *>(listener);
980 if (parserListener != nullptr)
981 parserListener->enterZconstraintblock(this);
982}
983
984void OMDParser::ZconstraintblockContext::exitRule(tree::ParseTreeListener *listener) {
985 auto parserListener = dynamic_cast<OMDListener *>(listener);
986 if (parserListener != nullptr)
987 parserListener->exitZconstraintblock(this);
988}
989
990
991std::any OMDParser::ZconstraintblockContext::accept(tree::ParseTreeVisitor *visitor) {
992 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
993 return parserVisitor->visitZconstraintblock(this);
994 else
995 return visitor->visitChildren(this);
996}
997
998OMDParser::ZconstraintblockContext* OMDParser::zconstraintblock() {
999 ZconstraintblockContext *_localctx = _tracker.createInstance<ZconstraintblockContext>(_ctx, getState());
1000 enterRule(_localctx, 10, OMDParser::RuleZconstraintblock);
1001 size_t _la = 0;
1002
1003#if __cplusplus > 201703L
1004 auto onExit = finally([=, this] {
1005#else
1006 auto onExit = finally([=] {
1007#endif
1008 exitRule();
1009 });
1010 try {
1011 enterOuterAlt(_localctx, 1);
1012 setState(127);
1013 match(OMDParser::ZCONSTRAINT);
1014 setState(128);
1015 match(OMDParser::LCURLY);
1016 setState(132);
1017 _errHandler->sync(this);
1018 _la = _input->LA(1);
1019 while (_la == OMDParser::ID) {
1020 setState(129);
1021 assignment();
1022 setState(134);
1023 _errHandler->sync(this);
1024 _la = _input->LA(1);
1025 }
1026 setState(135);
1027 match(OMDParser::RCURLY);
1028
1029 }
1030 catch (RecognitionException &e) {
1031 _errHandler->reportError(this, e);
1032 _localctx->exception = std::current_exception();
1033 _errHandler->recover(this, _localctx->exception);
1034 }
1035
1036 return _localctx;
1037}
1038
1039//----------------- RestraintblockContext ------------------------------------------------------------------
1040
1041OMDParser::RestraintblockContext::RestraintblockContext(ParserRuleContext *parent, size_t invokingState)
1042 : ParserRuleContext(parent, invokingState) {
1043}
1044
1045tree::TerminalNode* OMDParser::RestraintblockContext::RESTRAINT() {
1046 return getToken(OMDParser::RESTRAINT, 0);
1047}
1048
1049tree::TerminalNode* OMDParser::RestraintblockContext::LCURLY() {
1050 return getToken(OMDParser::LCURLY, 0);
1051}
1052
1053tree::TerminalNode* OMDParser::RestraintblockContext::RCURLY() {
1054 return getToken(OMDParser::RCURLY, 0);
1055}
1056
1057std::vector<OMDParser::AssignmentContext *> OMDParser::RestraintblockContext::assignment() {
1058 return getRuleContexts<OMDParser::AssignmentContext>();
1059}
1060
1061OMDParser::AssignmentContext* OMDParser::RestraintblockContext::assignment(size_t i) {
1062 return getRuleContext<OMDParser::AssignmentContext>(i);
1063}
1064
1065
1066size_t OMDParser::RestraintblockContext::getRuleIndex() const {
1067 return OMDParser::RuleRestraintblock;
1068}
1069
1070void OMDParser::RestraintblockContext::enterRule(tree::ParseTreeListener *listener) {
1071 auto parserListener = dynamic_cast<OMDListener *>(listener);
1072 if (parserListener != nullptr)
1073 parserListener->enterRestraintblock(this);
1074}
1075
1076void OMDParser::RestraintblockContext::exitRule(tree::ParseTreeListener *listener) {
1077 auto parserListener = dynamic_cast<OMDListener *>(listener);
1078 if (parserListener != nullptr)
1079 parserListener->exitRestraintblock(this);
1080}
1081
1082
1083std::any OMDParser::RestraintblockContext::accept(tree::ParseTreeVisitor *visitor) {
1084 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1085 return parserVisitor->visitRestraintblock(this);
1086 else
1087 return visitor->visitChildren(this);
1088}
1089
1090OMDParser::RestraintblockContext* OMDParser::restraintblock() {
1091 RestraintblockContext *_localctx = _tracker.createInstance<RestraintblockContext>(_ctx, getState());
1092 enterRule(_localctx, 12, OMDParser::RuleRestraintblock);
1093 size_t _la = 0;
1094
1095#if __cplusplus > 201703L
1096 auto onExit = finally([=, this] {
1097#else
1098 auto onExit = finally([=] {
1099#endif
1100 exitRule();
1101 });
1102 try {
1103 enterOuterAlt(_localctx, 1);
1104 setState(137);
1105 match(OMDParser::RESTRAINT);
1106 setState(138);
1107 match(OMDParser::LCURLY);
1108 setState(142);
1109 _errHandler->sync(this);
1110 _la = _input->LA(1);
1111 while (_la == OMDParser::ID) {
1112 setState(139);
1113 assignment();
1114 setState(144);
1115 _errHandler->sync(this);
1116 _la = _input->LA(1);
1117 }
1118 setState(145);
1119 match(OMDParser::RCURLY);
1120
1121 }
1122 catch (RecognitionException &e) {
1123 _errHandler->reportError(this, e);
1124 _localctx->exception = std::current_exception();
1125 _errHandler->recover(this, _localctx->exception);
1126 }
1127
1128 return _localctx;
1129}
1130
1131//----------------- FlucqblockContext ------------------------------------------------------------------
1132
1133OMDParser::FlucqblockContext::FlucqblockContext(ParserRuleContext *parent, size_t invokingState)
1134 : ParserRuleContext(parent, invokingState) {
1135}
1136
1137tree::TerminalNode* OMDParser::FlucqblockContext::FLUCQ() {
1138 return getToken(OMDParser::FLUCQ, 0);
1139}
1140
1141tree::TerminalNode* OMDParser::FlucqblockContext::LCURLY() {
1142 return getToken(OMDParser::LCURLY, 0);
1143}
1144
1145tree::TerminalNode* OMDParser::FlucqblockContext::RCURLY() {
1146 return getToken(OMDParser::RCURLY, 0);
1147}
1148
1149std::vector<OMDParser::AssignmentContext *> OMDParser::FlucqblockContext::assignment() {
1150 return getRuleContexts<OMDParser::AssignmentContext>();
1151}
1152
1153OMDParser::AssignmentContext* OMDParser::FlucqblockContext::assignment(size_t i) {
1154 return getRuleContext<OMDParser::AssignmentContext>(i);
1155}
1156
1157
1158size_t OMDParser::FlucqblockContext::getRuleIndex() const {
1159 return OMDParser::RuleFlucqblock;
1160}
1161
1162void OMDParser::FlucqblockContext::enterRule(tree::ParseTreeListener *listener) {
1163 auto parserListener = dynamic_cast<OMDListener *>(listener);
1164 if (parserListener != nullptr)
1165 parserListener->enterFlucqblock(this);
1166}
1167
1168void OMDParser::FlucqblockContext::exitRule(tree::ParseTreeListener *listener) {
1169 auto parserListener = dynamic_cast<OMDListener *>(listener);
1170 if (parserListener != nullptr)
1171 parserListener->exitFlucqblock(this);
1172}
1173
1174
1175std::any OMDParser::FlucqblockContext::accept(tree::ParseTreeVisitor *visitor) {
1176 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1177 return parserVisitor->visitFlucqblock(this);
1178 else
1179 return visitor->visitChildren(this);
1180}
1181
1182OMDParser::FlucqblockContext* OMDParser::flucqblock() {
1183 FlucqblockContext *_localctx = _tracker.createInstance<FlucqblockContext>(_ctx, getState());
1184 enterRule(_localctx, 14, OMDParser::RuleFlucqblock);
1185 size_t _la = 0;
1186
1187#if __cplusplus > 201703L
1188 auto onExit = finally([=, this] {
1189#else
1190 auto onExit = finally([=] {
1191#endif
1192 exitRule();
1193 });
1194 try {
1195 enterOuterAlt(_localctx, 1);
1196 setState(147);
1197 match(OMDParser::FLUCQ);
1198 setState(148);
1199 match(OMDParser::LCURLY);
1200 setState(152);
1201 _errHandler->sync(this);
1202 _la = _input->LA(1);
1203 while (_la == OMDParser::ID) {
1204 setState(149);
1205 assignment();
1206 setState(154);
1207 _errHandler->sync(this);
1208 _la = _input->LA(1);
1209 }
1210 setState(155);
1211 match(OMDParser::RCURLY);
1212
1213 }
1214 catch (RecognitionException &e) {
1215 _errHandler->reportError(this, e);
1216 _localctx->exception = std::current_exception();
1217 _errHandler->recover(this, _localctx->exception);
1218 }
1219
1220 return _localctx;
1221}
1222
1223//----------------- RnemdblockContext ------------------------------------------------------------------
1224
1225OMDParser::RnemdblockContext::RnemdblockContext(ParserRuleContext *parent, size_t invokingState)
1226 : ParserRuleContext(parent, invokingState) {
1227}
1228
1229tree::TerminalNode* OMDParser::RnemdblockContext::RNEMD() {
1230 return getToken(OMDParser::RNEMD, 0);
1231}
1232
1233tree::TerminalNode* OMDParser::RnemdblockContext::LCURLY() {
1234 return getToken(OMDParser::LCURLY, 0);
1235}
1236
1237tree::TerminalNode* OMDParser::RnemdblockContext::RCURLY() {
1238 return getToken(OMDParser::RCURLY, 0);
1239}
1240
1241std::vector<OMDParser::AssignmentContext *> OMDParser::RnemdblockContext::assignment() {
1242 return getRuleContexts<OMDParser::AssignmentContext>();
1243}
1244
1245OMDParser::AssignmentContext* OMDParser::RnemdblockContext::assignment(size_t i) {
1246 return getRuleContext<OMDParser::AssignmentContext>(i);
1247}
1248
1249
1250size_t OMDParser::RnemdblockContext::getRuleIndex() const {
1251 return OMDParser::RuleRnemdblock;
1252}
1253
1254void OMDParser::RnemdblockContext::enterRule(tree::ParseTreeListener *listener) {
1255 auto parserListener = dynamic_cast<OMDListener *>(listener);
1256 if (parserListener != nullptr)
1257 parserListener->enterRnemdblock(this);
1258}
1259
1260void OMDParser::RnemdblockContext::exitRule(tree::ParseTreeListener *listener) {
1261 auto parserListener = dynamic_cast<OMDListener *>(listener);
1262 if (parserListener != nullptr)
1263 parserListener->exitRnemdblock(this);
1264}
1265
1266
1267std::any OMDParser::RnemdblockContext::accept(tree::ParseTreeVisitor *visitor) {
1268 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1269 return parserVisitor->visitRnemdblock(this);
1270 else
1271 return visitor->visitChildren(this);
1272}
1273
1274OMDParser::RnemdblockContext* OMDParser::rnemdblock() {
1275 RnemdblockContext *_localctx = _tracker.createInstance<RnemdblockContext>(_ctx, getState());
1276 enterRule(_localctx, 16, OMDParser::RuleRnemdblock);
1277 size_t _la = 0;
1278
1279#if __cplusplus > 201703L
1280 auto onExit = finally([=, this] {
1281#else
1282 auto onExit = finally([=] {
1283#endif
1284 exitRule();
1285 });
1286 try {
1287 enterOuterAlt(_localctx, 1);
1288 setState(157);
1289 match(OMDParser::RNEMD);
1290 setState(158);
1291 match(OMDParser::LCURLY);
1292 setState(162);
1293 _errHandler->sync(this);
1294 _la = _input->LA(1);
1295 while (_la == OMDParser::ID) {
1296 setState(159);
1297 assignment();
1298 setState(164);
1299 _errHandler->sync(this);
1300 _la = _input->LA(1);
1301 }
1302 setState(165);
1303 match(OMDParser::RCURLY);
1304
1305 }
1306 catch (RecognitionException &e) {
1307 _errHandler->reportError(this, e);
1308 _localctx->exception = std::current_exception();
1309 _errHandler->recover(this, _localctx->exception);
1310 }
1311
1312 return _localctx;
1313}
1314
1315//----------------- LightblockContext ------------------------------------------------------------------
1316
1317OMDParser::LightblockContext::LightblockContext(ParserRuleContext *parent, size_t invokingState)
1318 : ParserRuleContext(parent, invokingState) {
1319}
1320
1321tree::TerminalNode* OMDParser::LightblockContext::LIGHT() {
1322 return getToken(OMDParser::LIGHT, 0);
1323}
1324
1325tree::TerminalNode* OMDParser::LightblockContext::LCURLY() {
1326 return getToken(OMDParser::LCURLY, 0);
1327}
1328
1329tree::TerminalNode* OMDParser::LightblockContext::RCURLY() {
1330 return getToken(OMDParser::RCURLY, 0);
1331}
1332
1333std::vector<OMDParser::AssignmentContext *> OMDParser::LightblockContext::assignment() {
1334 return getRuleContexts<OMDParser::AssignmentContext>();
1335}
1336
1337OMDParser::AssignmentContext* OMDParser::LightblockContext::assignment(size_t i) {
1338 return getRuleContext<OMDParser::AssignmentContext>(i);
1339}
1340
1341
1342size_t OMDParser::LightblockContext::getRuleIndex() const {
1343 return OMDParser::RuleLightblock;
1344}
1345
1346void OMDParser::LightblockContext::enterRule(tree::ParseTreeListener *listener) {
1347 auto parserListener = dynamic_cast<OMDListener *>(listener);
1348 if (parserListener != nullptr)
1349 parserListener->enterLightblock(this);
1350}
1351
1352void OMDParser::LightblockContext::exitRule(tree::ParseTreeListener *listener) {
1353 auto parserListener = dynamic_cast<OMDListener *>(listener);
1354 if (parserListener != nullptr)
1355 parserListener->exitLightblock(this);
1356}
1357
1358
1359std::any OMDParser::LightblockContext::accept(tree::ParseTreeVisitor *visitor) {
1360 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1361 return parserVisitor->visitLightblock(this);
1362 else
1363 return visitor->visitChildren(this);
1364}
1365
1366OMDParser::LightblockContext* OMDParser::lightblock() {
1367 LightblockContext *_localctx = _tracker.createInstance<LightblockContext>(_ctx, getState());
1368 enterRule(_localctx, 18, OMDParser::RuleLightblock);
1369 size_t _la = 0;
1370
1371#if __cplusplus > 201703L
1372 auto onExit = finally([=, this] {
1373#else
1374 auto onExit = finally([=] {
1375#endif
1376 exitRule();
1377 });
1378 try {
1379 enterOuterAlt(_localctx, 1);
1380 setState(167);
1381 match(OMDParser::LIGHT);
1382 setState(168);
1383 match(OMDParser::LCURLY);
1384 setState(172);
1385 _errHandler->sync(this);
1386 _la = _input->LA(1);
1387 while (_la == OMDParser::ID) {
1388 setState(169);
1389 assignment();
1390 setState(174);
1391 _errHandler->sync(this);
1392 _la = _input->LA(1);
1393 }
1394 setState(175);
1395 match(OMDParser::RCURLY);
1396
1397 }
1398 catch (RecognitionException &e) {
1399 _errHandler->reportError(this, e);
1400 _localctx->exception = std::current_exception();
1401 _errHandler->recover(this, _localctx->exception);
1402 }
1403
1404 return _localctx;
1405}
1406
1407//----------------- VelocityfieldblockContext ------------------------------------------------------------------
1408
1409OMDParser::VelocityfieldblockContext::VelocityfieldblockContext(ParserRuleContext *parent, size_t invokingState)
1410 : ParserRuleContext(parent, invokingState) {
1411}
1412
1413tree::TerminalNode* OMDParser::VelocityfieldblockContext::VELOCITYFIELD() {
1414 return getToken(OMDParser::VELOCITYFIELD, 0);
1415}
1416
1417tree::TerminalNode* OMDParser::VelocityfieldblockContext::LCURLY() {
1418 return getToken(OMDParser::LCURLY, 0);
1419}
1420
1421tree::TerminalNode* OMDParser::VelocityfieldblockContext::RCURLY() {
1422 return getToken(OMDParser::RCURLY, 0);
1423}
1424
1425std::vector<OMDParser::AssignmentContext *> OMDParser::VelocityfieldblockContext::assignment() {
1426 return getRuleContexts<OMDParser::AssignmentContext>();
1427}
1428
1429OMDParser::AssignmentContext* OMDParser::VelocityfieldblockContext::assignment(size_t i) {
1430 return getRuleContext<OMDParser::AssignmentContext>(i);
1431}
1432
1433
1434size_t OMDParser::VelocityfieldblockContext::getRuleIndex() const {
1435 return OMDParser::RuleVelocityfieldblock;
1436}
1437
1438void OMDParser::VelocityfieldblockContext::enterRule(tree::ParseTreeListener *listener) {
1439 auto parserListener = dynamic_cast<OMDListener *>(listener);
1440 if (parserListener != nullptr)
1441 parserListener->enterVelocityfieldblock(this);
1442}
1443
1444void OMDParser::VelocityfieldblockContext::exitRule(tree::ParseTreeListener *listener) {
1445 auto parserListener = dynamic_cast<OMDListener *>(listener);
1446 if (parserListener != nullptr)
1447 parserListener->exitVelocityfieldblock(this);
1448}
1449
1450
1451std::any OMDParser::VelocityfieldblockContext::accept(tree::ParseTreeVisitor *visitor) {
1452 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1453 return parserVisitor->visitVelocityfieldblock(this);
1454 else
1455 return visitor->visitChildren(this);
1456}
1457
1458OMDParser::VelocityfieldblockContext* OMDParser::velocityfieldblock() {
1459 VelocityfieldblockContext *_localctx = _tracker.createInstance<VelocityfieldblockContext>(_ctx, getState());
1460 enterRule(_localctx, 20, OMDParser::RuleVelocityfieldblock);
1461 size_t _la = 0;
1462
1463#if __cplusplus > 201703L
1464 auto onExit = finally([=, this] {
1465#else
1466 auto onExit = finally([=] {
1467#endif
1468 exitRule();
1469 });
1470 try {
1471 enterOuterAlt(_localctx, 1);
1472 setState(177);
1473 match(OMDParser::VELOCITYFIELD);
1474 setState(178);
1475 match(OMDParser::LCURLY);
1476 setState(182);
1477 _errHandler->sync(this);
1478 _la = _input->LA(1);
1479 while (_la == OMDParser::ID) {
1480 setState(179);
1481 assignment();
1482 setState(184);
1483 _errHandler->sync(this);
1484 _la = _input->LA(1);
1485 }
1486 setState(185);
1487 match(OMDParser::RCURLY);
1488
1489 }
1490 catch (RecognitionException &e) {
1491 _errHandler->reportError(this, e);
1492 _localctx->exception = std::current_exception();
1493 _errHandler->recover(this, _localctx->exception);
1494 }
1495
1496 return _localctx;
1497}
1498
1499//----------------- MinimizerblockContext ------------------------------------------------------------------
1500
1501OMDParser::MinimizerblockContext::MinimizerblockContext(ParserRuleContext *parent, size_t invokingState)
1502 : ParserRuleContext(parent, invokingState) {
1503}
1504
1505tree::TerminalNode* OMDParser::MinimizerblockContext::MINIMIZER() {
1506 return getToken(OMDParser::MINIMIZER, 0);
1507}
1508
1509tree::TerminalNode* OMDParser::MinimizerblockContext::LCURLY() {
1510 return getToken(OMDParser::LCURLY, 0);
1511}
1512
1513tree::TerminalNode* OMDParser::MinimizerblockContext::RCURLY() {
1514 return getToken(OMDParser::RCURLY, 0);
1515}
1516
1517std::vector<OMDParser::AssignmentContext *> OMDParser::MinimizerblockContext::assignment() {
1518 return getRuleContexts<OMDParser::AssignmentContext>();
1519}
1520
1521OMDParser::AssignmentContext* OMDParser::MinimizerblockContext::assignment(size_t i) {
1522 return getRuleContext<OMDParser::AssignmentContext>(i);
1523}
1524
1525
1526size_t OMDParser::MinimizerblockContext::getRuleIndex() const {
1527 return OMDParser::RuleMinimizerblock;
1528}
1529
1530void OMDParser::MinimizerblockContext::enterRule(tree::ParseTreeListener *listener) {
1531 auto parserListener = dynamic_cast<OMDListener *>(listener);
1532 if (parserListener != nullptr)
1533 parserListener->enterMinimizerblock(this);
1534}
1535
1536void OMDParser::MinimizerblockContext::exitRule(tree::ParseTreeListener *listener) {
1537 auto parserListener = dynamic_cast<OMDListener *>(listener);
1538 if (parserListener != nullptr)
1539 parserListener->exitMinimizerblock(this);
1540}
1541
1542
1543std::any OMDParser::MinimizerblockContext::accept(tree::ParseTreeVisitor *visitor) {
1544 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1545 return parserVisitor->visitMinimizerblock(this);
1546 else
1547 return visitor->visitChildren(this);
1548}
1549
1550OMDParser::MinimizerblockContext* OMDParser::minimizerblock() {
1551 MinimizerblockContext *_localctx = _tracker.createInstance<MinimizerblockContext>(_ctx, getState());
1552 enterRule(_localctx, 22, OMDParser::RuleMinimizerblock);
1553 size_t _la = 0;
1554
1555#if __cplusplus > 201703L
1556 auto onExit = finally([=, this] {
1557#else
1558 auto onExit = finally([=] {
1559#endif
1560 exitRule();
1561 });
1562 try {
1563 enterOuterAlt(_localctx, 1);
1564 setState(187);
1565 match(OMDParser::MINIMIZER);
1566 setState(188);
1567 match(OMDParser::LCURLY);
1568 setState(192);
1569 _errHandler->sync(this);
1570 _la = _input->LA(1);
1571 while (_la == OMDParser::ID) {
1572 setState(189);
1573 assignment();
1574 setState(194);
1575 _errHandler->sync(this);
1576 _la = _input->LA(1);
1577 }
1578 setState(195);
1579 match(OMDParser::RCURLY);
1580
1581 }
1582 catch (RecognitionException &e) {
1583 _errHandler->reportError(this, e);
1584 _localctx->exception = std::current_exception();
1585 _errHandler->recover(this, _localctx->exception);
1586 }
1587
1588 return _localctx;
1589}
1590
1591//----------------- MoleculeblockContext ------------------------------------------------------------------
1592
1593OMDParser::MoleculeblockContext::MoleculeblockContext(ParserRuleContext *parent, size_t invokingState)
1594 : ParserRuleContext(parent, invokingState) {
1595}
1596
1597tree::TerminalNode* OMDParser::MoleculeblockContext::MOLECULE() {
1598 return getToken(OMDParser::MOLECULE, 0);
1599}
1600
1601tree::TerminalNode* OMDParser::MoleculeblockContext::LCURLY() {
1602 return getToken(OMDParser::LCURLY, 0);
1603}
1604
1605tree::TerminalNode* OMDParser::MoleculeblockContext::RCURLY() {
1606 return getToken(OMDParser::RCURLY, 0);
1607}
1608
1609std::vector<OMDParser::MoleculestatementContext *> OMDParser::MoleculeblockContext::moleculestatement() {
1610 return getRuleContexts<OMDParser::MoleculestatementContext>();
1611}
1612
1613OMDParser::MoleculestatementContext* OMDParser::MoleculeblockContext::moleculestatement(size_t i) {
1614 return getRuleContext<OMDParser::MoleculestatementContext>(i);
1615}
1616
1617
1618size_t OMDParser::MoleculeblockContext::getRuleIndex() const {
1619 return OMDParser::RuleMoleculeblock;
1620}
1621
1622void OMDParser::MoleculeblockContext::enterRule(tree::ParseTreeListener *listener) {
1623 auto parserListener = dynamic_cast<OMDListener *>(listener);
1624 if (parserListener != nullptr)
1625 parserListener->enterMoleculeblock(this);
1626}
1627
1628void OMDParser::MoleculeblockContext::exitRule(tree::ParseTreeListener *listener) {
1629 auto parserListener = dynamic_cast<OMDListener *>(listener);
1630 if (parserListener != nullptr)
1631 parserListener->exitMoleculeblock(this);
1632}
1633
1634
1635std::any OMDParser::MoleculeblockContext::accept(tree::ParseTreeVisitor *visitor) {
1636 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1637 return parserVisitor->visitMoleculeblock(this);
1638 else
1639 return visitor->visitChildren(this);
1640}
1641
1642OMDParser::MoleculeblockContext* OMDParser::moleculeblock() {
1643 MoleculeblockContext *_localctx = _tracker.createInstance<MoleculeblockContext>(_ctx, getState());
1644 enterRule(_localctx, 24, OMDParser::RuleMoleculeblock);
1645 size_t _la = 0;
1646
1647#if __cplusplus > 201703L
1648 auto onExit = finally([=, this] {
1649#else
1650 auto onExit = finally([=] {
1651#endif
1652 exitRule();
1653 });
1654 try {
1655 enterOuterAlt(_localctx, 1);
1656 setState(197);
1657 match(OMDParser::MOLECULE);
1658 setState(198);
1659 match(OMDParser::LCURLY);
1660 setState(202);
1661 _errHandler->sync(this);
1662 _la = _input->LA(1);
1663 while (((((_la - 7) & ~ 0x3fULL) == 0) &&
1664 ((1ULL << (_la - 7)) & 288230376151713023) != 0)) {
1665 setState(199);
1666 moleculestatement();
1667 setState(204);
1668 _errHandler->sync(this);
1669 _la = _input->LA(1);
1670 }
1671 setState(205);
1672 match(OMDParser::RCURLY);
1673
1674 }
1675 catch (RecognitionException &e) {
1676 _errHandler->reportError(this, e);
1677 _localctx->exception = std::current_exception();
1678 _errHandler->recover(this, _localctx->exception);
1679 }
1680
1681 return _localctx;
1682}
1683
1684//----------------- MoleculestatementContext ------------------------------------------------------------------
1685
1686OMDParser::MoleculestatementContext::MoleculestatementContext(ParserRuleContext *parent, size_t invokingState)
1687 : ParserRuleContext(parent, invokingState) {
1688}
1689
1690OMDParser::AssignmentContext* OMDParser::MoleculestatementContext::assignment() {
1691 return getRuleContext<OMDParser::AssignmentContext>(0);
1692}
1693
1694OMDParser::AtomblockContext* OMDParser::MoleculestatementContext::atomblock() {
1695 return getRuleContext<OMDParser::AtomblockContext>(0);
1696}
1697
1698OMDParser::BondblockContext* OMDParser::MoleculestatementContext::bondblock() {
1699 return getRuleContext<OMDParser::BondblockContext>(0);
1700}
1701
1702OMDParser::BendblockContext* OMDParser::MoleculestatementContext::bendblock() {
1703 return getRuleContext<OMDParser::BendblockContext>(0);
1704}
1705
1706OMDParser::TorsionblockContext* OMDParser::MoleculestatementContext::torsionblock() {
1707 return getRuleContext<OMDParser::TorsionblockContext>(0);
1708}
1709
1710OMDParser::InversionblockContext* OMDParser::MoleculestatementContext::inversionblock() {
1711 return getRuleContext<OMDParser::InversionblockContext>(0);
1712}
1713
1714OMDParser::RigidbodyblockContext* OMDParser::MoleculestatementContext::rigidbodyblock() {
1715 return getRuleContext<OMDParser::RigidbodyblockContext>(0);
1716}
1717
1718OMDParser::CutoffgroupblockContext* OMDParser::MoleculestatementContext::cutoffgroupblock() {
1719 return getRuleContext<OMDParser::CutoffgroupblockContext>(0);
1720}
1721
1722OMDParser::ConstraintblockContext* OMDParser::MoleculestatementContext::constraintblock() {
1723 return getRuleContext<OMDParser::ConstraintblockContext>(0);
1724}
1725
1726OMDParser::SequencestringContext* OMDParser::MoleculestatementContext::sequencestring() {
1727 return getRuleContext<OMDParser::SequencestringContext>(0);
1728}
1729
1730
1731size_t OMDParser::MoleculestatementContext::getRuleIndex() const {
1732 return OMDParser::RuleMoleculestatement;
1733}
1734
1735void OMDParser::MoleculestatementContext::enterRule(tree::ParseTreeListener *listener) {
1736 auto parserListener = dynamic_cast<OMDListener *>(listener);
1737 if (parserListener != nullptr)
1738 parserListener->enterMoleculestatement(this);
1739}
1740
1741void OMDParser::MoleculestatementContext::exitRule(tree::ParseTreeListener *listener) {
1742 auto parserListener = dynamic_cast<OMDListener *>(listener);
1743 if (parserListener != nullptr)
1744 parserListener->exitMoleculestatement(this);
1745}
1746
1747
1748std::any OMDParser::MoleculestatementContext::accept(tree::ParseTreeVisitor *visitor) {
1749 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1750 return parserVisitor->visitMoleculestatement(this);
1751 else
1752 return visitor->visitChildren(this);
1753}
1754
1755OMDParser::MoleculestatementContext* OMDParser::moleculestatement() {
1756 MoleculestatementContext *_localctx = _tracker.createInstance<MoleculestatementContext>(_ctx, getState());
1757 enterRule(_localctx, 26, OMDParser::RuleMoleculestatement);
1758
1759#if __cplusplus > 201703L
1760 auto onExit = finally([=, this] {
1761#else
1762 auto onExit = finally([=] {
1763#endif
1764 exitRule();
1765 });
1766 try {
1767 setState(217);
1768 _errHandler->sync(this);
1769 switch (_input->LA(1)) {
1770 case OMDParser::ID: {
1771 enterOuterAlt(_localctx, 1);
1772 setState(207);
1773 assignment();
1774 break;
1775 }
1776
1777 case OMDParser::ATOM: {
1778 enterOuterAlt(_localctx, 2);
1779 setState(208);
1780 atomblock();
1781 break;
1782 }
1783
1784 case OMDParser::BOND: {
1785 enterOuterAlt(_localctx, 3);
1786 setState(209);
1787 bondblock();
1788 break;
1789 }
1790
1791 case OMDParser::BEND: {
1792 enterOuterAlt(_localctx, 4);
1793 setState(210);
1794 bendblock();
1795 break;
1796 }
1797
1798 case OMDParser::TORSION: {
1799 enterOuterAlt(_localctx, 5);
1800 setState(211);
1801 torsionblock();
1802 break;
1803 }
1804
1805 case OMDParser::INVERSION: {
1806 enterOuterAlt(_localctx, 6);
1807 setState(212);
1808 inversionblock();
1809 break;
1810 }
1811
1812 case OMDParser::RIGIDBODY: {
1813 enterOuterAlt(_localctx, 7);
1814 setState(213);
1815 rigidbodyblock();
1816 break;
1817 }
1818
1819 case OMDParser::CUTOFFGROUP: {
1820 enterOuterAlt(_localctx, 8);
1821 setState(214);
1822 cutoffgroupblock();
1823 break;
1824 }
1825
1826 case OMDParser::CONSTRAINT: {
1827 enterOuterAlt(_localctx, 9);
1828 setState(215);
1829 constraintblock();
1830 break;
1831 }
1832
1833 case OMDParser::SEQUENCE: {
1834 enterOuterAlt(_localctx, 10);
1835 setState(216);
1836 sequencestring();
1837 break;
1838 }
1839
1840 default:
1841 throw NoViableAltException(this);
1842 }
1843
1844 }
1845 catch (RecognitionException &e) {
1846 _errHandler->reportError(this, e);
1847 _localctx->exception = std::current_exception();
1848 _errHandler->recover(this, _localctx->exception);
1849 }
1850
1851 return _localctx;
1852}
1853
1854//----------------- AtomblockContext ------------------------------------------------------------------
1855
1856OMDParser::AtomblockContext::AtomblockContext(ParserRuleContext *parent, size_t invokingState)
1857 : ParserRuleContext(parent, invokingState) {
1858}
1859
1860tree::TerminalNode* OMDParser::AtomblockContext::ATOM() {
1861 return getToken(OMDParser::ATOM, 0);
1862}
1863
1864tree::TerminalNode* OMDParser::AtomblockContext::LBRACKET() {
1865 return getToken(OMDParser::LBRACKET, 0);
1866}
1867
1868OMDParser::IntConstContext* OMDParser::AtomblockContext::intConst() {
1869 return getRuleContext<OMDParser::IntConstContext>(0);
1870}
1871
1872tree::TerminalNode* OMDParser::AtomblockContext::RBRACKET() {
1873 return getToken(OMDParser::RBRACKET, 0);
1874}
1875
1876tree::TerminalNode* OMDParser::AtomblockContext::LCURLY() {
1877 return getToken(OMDParser::LCURLY, 0);
1878}
1879
1880tree::TerminalNode* OMDParser::AtomblockContext::RCURLY() {
1881 return getToken(OMDParser::RCURLY, 0);
1882}
1883
1884std::vector<OMDParser::AtomstatementContext *> OMDParser::AtomblockContext::atomstatement() {
1885 return getRuleContexts<OMDParser::AtomstatementContext>();
1886}
1887
1888OMDParser::AtomstatementContext* OMDParser::AtomblockContext::atomstatement(size_t i) {
1889 return getRuleContext<OMDParser::AtomstatementContext>(i);
1890}
1891
1892
1893size_t OMDParser::AtomblockContext::getRuleIndex() const {
1894 return OMDParser::RuleAtomblock;
1895}
1896
1897void OMDParser::AtomblockContext::enterRule(tree::ParseTreeListener *listener) {
1898 auto parserListener = dynamic_cast<OMDListener *>(listener);
1899 if (parserListener != nullptr)
1900 parserListener->enterAtomblock(this);
1901}
1902
1903void OMDParser::AtomblockContext::exitRule(tree::ParseTreeListener *listener) {
1904 auto parserListener = dynamic_cast<OMDListener *>(listener);
1905 if (parserListener != nullptr)
1906 parserListener->exitAtomblock(this);
1907}
1908
1909
1910std::any OMDParser::AtomblockContext::accept(tree::ParseTreeVisitor *visitor) {
1911 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
1912 return parserVisitor->visitAtomblock(this);
1913 else
1914 return visitor->visitChildren(this);
1915}
1916
1917OMDParser::AtomblockContext* OMDParser::atomblock() {
1918 AtomblockContext *_localctx = _tracker.createInstance<AtomblockContext>(_ctx, getState());
1919 enterRule(_localctx, 28, OMDParser::RuleAtomblock);
1920 size_t _la = 0;
1921
1922#if __cplusplus > 201703L
1923 auto onExit = finally([=, this] {
1924#else
1925 auto onExit = finally([=] {
1926#endif
1927 exitRule();
1928 });
1929 try {
1930 enterOuterAlt(_localctx, 1);
1931 setState(219);
1932 match(OMDParser::ATOM);
1933 setState(220);
1934 match(OMDParser::LBRACKET);
1935 setState(221);
1936 intConst();
1937 setState(222);
1938 match(OMDParser::RBRACKET);
1939 setState(223);
1940 match(OMDParser::LCURLY);
1941 setState(227);
1942 _errHandler->sync(this);
1943 _la = _input->LA(1);
1944 while (((((_la - 21) & ~ 0x3fULL) == 0) &&
1945 ((1ULL << (_la - 21)) & 17592202821635) != 0)) {
1946 setState(224);
1947 atomstatement();
1948 setState(229);
1949 _errHandler->sync(this);
1950 _la = _input->LA(1);
1951 }
1952 setState(230);
1953 match(OMDParser::RCURLY);
1954
1955 }
1956 catch (RecognitionException &e) {
1957 _errHandler->reportError(this, e);
1958 _localctx->exception = std::current_exception();
1959 _errHandler->recover(this, _localctx->exception);
1960 }
1961
1962 return _localctx;
1963}
1964
1965//----------------- AtomstatementContext ------------------------------------------------------------------
1966
1967OMDParser::AtomstatementContext::AtomstatementContext(ParserRuleContext *parent, size_t invokingState)
1968 : ParserRuleContext(parent, invokingState) {
1969}
1970
1971OMDParser::AssignmentContext* OMDParser::AtomstatementContext::assignment() {
1972 return getRuleContext<OMDParser::AssignmentContext>(0);
1973}
1974
1975tree::TerminalNode* OMDParser::AtomstatementContext::POSITION() {
1976 return getToken(OMDParser::POSITION, 0);
1977}
1978
1979tree::TerminalNode* OMDParser::AtomstatementContext::LPAREN() {
1980 return getToken(OMDParser::LPAREN, 0);
1981}
1982
1983OMDParser::DoubleNumberTupleContext* OMDParser::AtomstatementContext::doubleNumberTuple() {
1984 return getRuleContext<OMDParser::DoubleNumberTupleContext>(0);
1985}
1986
1987tree::TerminalNode* OMDParser::AtomstatementContext::RPAREN() {
1988 return getToken(OMDParser::RPAREN, 0);
1989}
1990
1991tree::TerminalNode* OMDParser::AtomstatementContext::SEMICOLON() {
1992 return getToken(OMDParser::SEMICOLON, 0);
1993}
1994
1995tree::TerminalNode* OMDParser::AtomstatementContext::ORIENTATION() {
1996 return getToken(OMDParser::ORIENTATION, 0);
1997}
1998
1999tree::TerminalNode* OMDParser::AtomstatementContext::CHARGE() {
2000 return getToken(OMDParser::CHARGE, 0);
2001}
2002
2003OMDParser::FloatConstContext* OMDParser::AtomstatementContext::floatConst() {
2004 return getRuleContext<OMDParser::FloatConstContext>(0);
2005}
2006
2007
2008size_t OMDParser::AtomstatementContext::getRuleIndex() const {
2009 return OMDParser::RuleAtomstatement;
2010}
2011
2012void OMDParser::AtomstatementContext::enterRule(tree::ParseTreeListener *listener) {
2013 auto parserListener = dynamic_cast<OMDListener *>(listener);
2014 if (parserListener != nullptr)
2015 parserListener->enterAtomstatement(this);
2016}
2017
2018void OMDParser::AtomstatementContext::exitRule(tree::ParseTreeListener *listener) {
2019 auto parserListener = dynamic_cast<OMDListener *>(listener);
2020 if (parserListener != nullptr)
2021 parserListener->exitAtomstatement(this);
2022}
2023
2024
2025std::any OMDParser::AtomstatementContext::accept(tree::ParseTreeVisitor *visitor) {
2026 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
2027 return parserVisitor->visitAtomstatement(this);
2028 else
2029 return visitor->visitChildren(this);
2030}
2031
2032OMDParser::AtomstatementContext* OMDParser::atomstatement() {
2033 AtomstatementContext *_localctx = _tracker.createInstance<AtomstatementContext>(_ctx, getState());
2034 enterRule(_localctx, 30, OMDParser::RuleAtomstatement);
2035
2036#if __cplusplus > 201703L
2037 auto onExit = finally([=, this] {
2038#else
2039 auto onExit = finally([=] {
2040#endif
2041 exitRule();
2042 });
2043 try {
2044 setState(251);
2045 _errHandler->sync(this);
2046 switch (_input->LA(1)) {
2047 case OMDParser::ID: {
2048 enterOuterAlt(_localctx, 1);
2049 setState(232);
2050 assignment();
2051 break;
2052 }
2053
2054 case OMDParser::POSITION: {
2055 enterOuterAlt(_localctx, 2);
2056 setState(233);
2057 match(OMDParser::POSITION);
2058 setState(234);
2059 match(OMDParser::LPAREN);
2060 setState(235);
2061 doubleNumberTuple();
2062 setState(236);
2063 match(OMDParser::RPAREN);
2064 setState(237);
2065 match(OMDParser::SEMICOLON);
2066 break;
2067 }
2068
2069 case OMDParser::ORIENTATION: {
2070 enterOuterAlt(_localctx, 3);
2071 setState(239);
2072 match(OMDParser::ORIENTATION);
2073 setState(240);
2074 match(OMDParser::LPAREN);
2075 setState(241);
2076 doubleNumberTuple();
2077 setState(242);
2078 match(OMDParser::RPAREN);
2079 setState(243);
2080 match(OMDParser::SEMICOLON);
2081 break;
2082 }
2083
2084 case OMDParser::CHARGE: {
2085 enterOuterAlt(_localctx, 4);
2086 setState(245);
2087 match(OMDParser::CHARGE);
2088 setState(246);
2089 match(OMDParser::LPAREN);
2090 setState(247);
2091 floatConst();
2092 setState(248);
2093 match(OMDParser::RPAREN);
2094 setState(249);
2095 match(OMDParser::SEMICOLON);
2096 break;
2097 }
2098
2099 default:
2100 throw NoViableAltException(this);
2101 }
2102
2103 }
2104 catch (RecognitionException &e) {
2105 _errHandler->reportError(this, e);
2106 _localctx->exception = std::current_exception();
2107 _errHandler->recover(this, _localctx->exception);
2108 }
2109
2110 return _localctx;
2111}
2112
2113//----------------- BondblockContext ------------------------------------------------------------------
2114
2115OMDParser::BondblockContext::BondblockContext(ParserRuleContext *parent, size_t invokingState)
2116 : ParserRuleContext(parent, invokingState) {
2117}
2118
2119tree::TerminalNode* OMDParser::BondblockContext::BOND() {
2120 return getToken(OMDParser::BOND, 0);
2121}
2122
2123tree::TerminalNode* OMDParser::BondblockContext::LCURLY() {
2124 return getToken(OMDParser::LCURLY, 0);
2125}
2126
2127tree::TerminalNode* OMDParser::BondblockContext::RCURLY() {
2128 return getToken(OMDParser::RCURLY, 0);
2129}
2130
2131tree::TerminalNode* OMDParser::BondblockContext::LBRACKET() {
2132 return getToken(OMDParser::LBRACKET, 0);
2133}
2134
2135OMDParser::IntConstContext* OMDParser::BondblockContext::intConst() {
2136 return getRuleContext<OMDParser::IntConstContext>(0);
2137}
2138
2139tree::TerminalNode* OMDParser::BondblockContext::RBRACKET() {
2140 return getToken(OMDParser::RBRACKET, 0);
2141}
2142
2143std::vector<OMDParser::BondstatementContext *> OMDParser::BondblockContext::bondstatement() {
2144 return getRuleContexts<OMDParser::BondstatementContext>();
2145}
2146
2147OMDParser::BondstatementContext* OMDParser::BondblockContext::bondstatement(size_t i) {
2148 return getRuleContext<OMDParser::BondstatementContext>(i);
2149}
2150
2151
2152size_t OMDParser::BondblockContext::getRuleIndex() const {
2153 return OMDParser::RuleBondblock;
2154}
2155
2156void OMDParser::BondblockContext::enterRule(tree::ParseTreeListener *listener) {
2157 auto parserListener = dynamic_cast<OMDListener *>(listener);
2158 if (parserListener != nullptr)
2159 parserListener->enterBondblock(this);
2160}
2161
2162void OMDParser::BondblockContext::exitRule(tree::ParseTreeListener *listener) {
2163 auto parserListener = dynamic_cast<OMDListener *>(listener);
2164 if (parserListener != nullptr)
2165 parserListener->exitBondblock(this);
2166}
2167
2168
2169std::any OMDParser::BondblockContext::accept(tree::ParseTreeVisitor *visitor) {
2170 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
2171 return parserVisitor->visitBondblock(this);
2172 else
2173 return visitor->visitChildren(this);
2174}
2175
2176OMDParser::BondblockContext* OMDParser::bondblock() {
2177 BondblockContext *_localctx = _tracker.createInstance<BondblockContext>(_ctx, getState());
2178 enterRule(_localctx, 32, OMDParser::RuleBondblock);
2179 size_t _la = 0;
2180
2181#if __cplusplus > 201703L
2182 auto onExit = finally([=, this] {
2183#else
2184 auto onExit = finally([=] {
2185#endif
2186 exitRule();
2187 });
2188 try {
2189 enterOuterAlt(_localctx, 1);
2190 setState(253);
2191 match(OMDParser::BOND);
2192 setState(258);
2193 _errHandler->sync(this);
2194
2195 _la = _input->LA(1);
2196 if (_la == OMDParser::LBRACKET) {
2197 setState(254);
2198 match(OMDParser::LBRACKET);
2199 setState(255);
2200 intConst();
2201 setState(256);
2202 match(OMDParser::RBRACKET);
2203 }
2204 setState(260);
2205 match(OMDParser::LCURLY);
2206 setState(264);
2207 _errHandler->sync(this);
2208 _la = _input->LA(1);
2209 while (((((_la - 18) & ~ 0x3fULL) == 0) &&
2210 ((1ULL << (_la - 18)) & 140737488419841) != 0)) {
2211 setState(261);
2212 bondstatement();
2213 setState(266);
2214 _errHandler->sync(this);
2215 _la = _input->LA(1);
2216 }
2217 setState(267);
2218 match(OMDParser::RCURLY);
2219
2220 }
2221 catch (RecognitionException &e) {
2222 _errHandler->reportError(this, e);
2223 _localctx->exception = std::current_exception();
2224 _errHandler->recover(this, _localctx->exception);
2225 }
2226
2227 return _localctx;
2228}
2229
2230//----------------- BondstatementContext ------------------------------------------------------------------
2231
2232OMDParser::BondstatementContext::BondstatementContext(ParserRuleContext *parent, size_t invokingState)
2233 : ParserRuleContext(parent, invokingState) {
2234}
2235
2236OMDParser::AssignmentContext* OMDParser::BondstatementContext::assignment() {
2237 return getRuleContext<OMDParser::AssignmentContext>(0);
2238}
2239
2240tree::TerminalNode* OMDParser::BondstatementContext::MEMBERS() {
2241 return getToken(OMDParser::MEMBERS, 0);
2242}
2243
2244tree::TerminalNode* OMDParser::BondstatementContext::LPAREN() {
2245 return getToken(OMDParser::LPAREN, 0);
2246}
2247
2248OMDParser::InttupleContext* OMDParser::BondstatementContext::inttuple() {
2249 return getRuleContext<OMDParser::InttupleContext>(0);
2250}
2251
2252tree::TerminalNode* OMDParser::BondstatementContext::RPAREN() {
2253 return getToken(OMDParser::RPAREN, 0);
2254}
2255
2256tree::TerminalNode* OMDParser::BondstatementContext::SEMICOLON() {
2257 return getToken(OMDParser::SEMICOLON, 0);
2258}
2259
2260tree::TerminalNode* OMDParser::BondstatementContext::FIXED() {
2261 return getToken(OMDParser::FIXED, 0);
2262}
2263
2264OMDParser::FloatConstContext* OMDParser::BondstatementContext::floatConst() {
2265 return getRuleContext<OMDParser::FloatConstContext>(0);
2266}
2267
2268tree::TerminalNode* OMDParser::BondstatementContext::HARMONIC() {
2269 return getToken(OMDParser::HARMONIC, 0);
2270}
2271
2272OMDParser::DoubleNumberTupleContext* OMDParser::BondstatementContext::doubleNumberTuple() {
2273 return getRuleContext<OMDParser::DoubleNumberTupleContext>(0);
2274}
2275
2276tree::TerminalNode* OMDParser::BondstatementContext::CUBIC() {
2277 return getToken(OMDParser::CUBIC, 0);
2278}
2279
2280tree::TerminalNode* OMDParser::BondstatementContext::QUARTIC() {
2281 return getToken(OMDParser::QUARTIC, 0);
2282}
2283
2284tree::TerminalNode* OMDParser::BondstatementContext::POLYNOMIAL() {
2285 return getToken(OMDParser::POLYNOMIAL, 0);
2286}
2287
2288tree::TerminalNode* OMDParser::BondstatementContext::MORSE() {
2289 return getToken(OMDParser::MORSE, 0);
2290}
2291
2292
2293size_t OMDParser::BondstatementContext::getRuleIndex() const {
2294 return OMDParser::RuleBondstatement;
2295}
2296
2297void OMDParser::BondstatementContext::enterRule(tree::ParseTreeListener *listener) {
2298 auto parserListener = dynamic_cast<OMDListener *>(listener);
2299 if (parserListener != nullptr)
2300 parserListener->enterBondstatement(this);
2301}
2302
2303void OMDParser::BondstatementContext::exitRule(tree::ParseTreeListener *listener) {
2304 auto parserListener = dynamic_cast<OMDListener *>(listener);
2305 if (parserListener != nullptr)
2306 parserListener->exitBondstatement(this);
2307}
2308
2309
2310std::any OMDParser::BondstatementContext::accept(tree::ParseTreeVisitor *visitor) {
2311 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
2312 return parserVisitor->visitBondstatement(this);
2313 else
2314 return visitor->visitChildren(this);
2315}
2316
2317OMDParser::BondstatementContext* OMDParser::bondstatement() {
2318 BondstatementContext *_localctx = _tracker.createInstance<BondstatementContext>(_ctx, getState());
2319 enterRule(_localctx, 34, OMDParser::RuleBondstatement);
2320
2321#if __cplusplus > 201703L
2322 auto onExit = finally([=, this] {
2323#else
2324 auto onExit = finally([=] {
2325#endif
2326 exitRule();
2327 });
2328 try {
2329 setState(312);
2330 _errHandler->sync(this);
2331 switch (_input->LA(1)) {
2332 case OMDParser::ID: {
2333 enterOuterAlt(_localctx, 1);
2334 setState(269);
2335 assignment();
2336 break;
2337 }
2338
2339 case OMDParser::MEMBERS: {
2340 enterOuterAlt(_localctx, 2);
2341 setState(270);
2342 match(OMDParser::MEMBERS);
2343 setState(271);
2344 match(OMDParser::LPAREN);
2345 setState(272);
2346 inttuple();
2347 setState(273);
2348 match(OMDParser::RPAREN);
2349 setState(274);
2350 match(OMDParser::SEMICOLON);
2351 break;
2352 }
2353
2354 case OMDParser::FIXED: {
2355 enterOuterAlt(_localctx, 3);
2356 setState(276);
2357 match(OMDParser::FIXED);
2358 setState(277);
2359 match(OMDParser::LPAREN);
2360 setState(278);
2361 floatConst();
2362 setState(279);
2363 match(OMDParser::RPAREN);
2364 setState(280);
2365 match(OMDParser::SEMICOLON);
2366 break;
2367 }
2368
2369 case OMDParser::HARMONIC: {
2370 enterOuterAlt(_localctx, 4);
2371 setState(282);
2372 match(OMDParser::HARMONIC);
2373 setState(283);
2374 match(OMDParser::LPAREN);
2375 setState(284);
2376 doubleNumberTuple();
2377 setState(285);
2378 match(OMDParser::RPAREN);
2379 setState(286);
2380 match(OMDParser::SEMICOLON);
2381 break;
2382 }
2383
2384 case OMDParser::CUBIC: {
2385 enterOuterAlt(_localctx, 5);
2386 setState(288);
2387 match(OMDParser::CUBIC);
2388 setState(289);
2389 match(OMDParser::LPAREN);
2390 setState(290);
2391 doubleNumberTuple();
2392 setState(291);
2393 match(OMDParser::RPAREN);
2394 setState(292);
2395 match(OMDParser::SEMICOLON);
2396 break;
2397 }
2398
2399 case OMDParser::QUARTIC: {
2400 enterOuterAlt(_localctx, 6);
2401 setState(294);
2402 match(OMDParser::QUARTIC);
2403 setState(295);
2404 match(OMDParser::LPAREN);
2405 setState(296);
2406 doubleNumberTuple();
2407 setState(297);
2408 match(OMDParser::RPAREN);
2409 setState(298);
2410 match(OMDParser::SEMICOLON);
2411 break;
2412 }
2413
2414 case OMDParser::POLYNOMIAL: {
2415 enterOuterAlt(_localctx, 7);
2416 setState(300);
2417 match(OMDParser::POLYNOMIAL);
2418 setState(301);
2419 match(OMDParser::LPAREN);
2420 setState(302);
2421 doubleNumberTuple();
2422 setState(303);
2423 match(OMDParser::RPAREN);
2424 setState(304);
2425 match(OMDParser::SEMICOLON);
2426 break;
2427 }
2428
2429 case OMDParser::MORSE: {
2430 enterOuterAlt(_localctx, 8);
2431 setState(306);
2432 match(OMDParser::MORSE);
2433 setState(307);
2434 match(OMDParser::LPAREN);
2435 setState(308);
2436 doubleNumberTuple();
2437 setState(309);
2438 match(OMDParser::RPAREN);
2439 setState(310);
2440 match(OMDParser::SEMICOLON);
2441 break;
2442 }
2443
2444 default:
2445 throw NoViableAltException(this);
2446 }
2447
2448 }
2449 catch (RecognitionException &e) {
2450 _errHandler->reportError(this, e);
2451 _localctx->exception = std::current_exception();
2452 _errHandler->recover(this, _localctx->exception);
2453 }
2454
2455 return _localctx;
2456}
2457
2458//----------------- BendblockContext ------------------------------------------------------------------
2459
2460OMDParser::BendblockContext::BendblockContext(ParserRuleContext *parent, size_t invokingState)
2461 : ParserRuleContext(parent, invokingState) {
2462}
2463
2464tree::TerminalNode* OMDParser::BendblockContext::BEND() {
2465 return getToken(OMDParser::BEND, 0);
2466}
2467
2468tree::TerminalNode* OMDParser::BendblockContext::LCURLY() {
2469 return getToken(OMDParser::LCURLY, 0);
2470}
2471
2472tree::TerminalNode* OMDParser::BendblockContext::RCURLY() {
2473 return getToken(OMDParser::RCURLY, 0);
2474}
2475
2476tree::TerminalNode* OMDParser::BendblockContext::LBRACKET() {
2477 return getToken(OMDParser::LBRACKET, 0);
2478}
2479
2480OMDParser::IntConstContext* OMDParser::BendblockContext::intConst() {
2481 return getRuleContext<OMDParser::IntConstContext>(0);
2482}
2483
2484tree::TerminalNode* OMDParser::BendblockContext::RBRACKET() {
2485 return getToken(OMDParser::RBRACKET, 0);
2486}
2487
2488std::vector<OMDParser::BendstatementContext *> OMDParser::BendblockContext::bendstatement() {
2489 return getRuleContexts<OMDParser::BendstatementContext>();
2490}
2491
2492OMDParser::BendstatementContext* OMDParser::BendblockContext::bendstatement(size_t i) {
2493 return getRuleContext<OMDParser::BendstatementContext>(i);
2494}
2495
2496
2497size_t OMDParser::BendblockContext::getRuleIndex() const {
2498 return OMDParser::RuleBendblock;
2499}
2500
2501void OMDParser::BendblockContext::enterRule(tree::ParseTreeListener *listener) {
2502 auto parserListener = dynamic_cast<OMDListener *>(listener);
2503 if (parserListener != nullptr)
2504 parserListener->enterBendblock(this);
2505}
2506
2507void OMDParser::BendblockContext::exitRule(tree::ParseTreeListener *listener) {
2508 auto parserListener = dynamic_cast<OMDListener *>(listener);
2509 if (parserListener != nullptr)
2510 parserListener->exitBendblock(this);
2511}
2512
2513
2514std::any OMDParser::BendblockContext::accept(tree::ParseTreeVisitor *visitor) {
2515 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
2516 return parserVisitor->visitBendblock(this);
2517 else
2518 return visitor->visitChildren(this);
2519}
2520
2521OMDParser::BendblockContext* OMDParser::bendblock() {
2522 BendblockContext *_localctx = _tracker.createInstance<BendblockContext>(_ctx, getState());
2523 enterRule(_localctx, 36, OMDParser::RuleBendblock);
2524 size_t _la = 0;
2525
2526#if __cplusplus > 201703L
2527 auto onExit = finally([=, this] {
2528#else
2529 auto onExit = finally([=] {
2530#endif
2531 exitRule();
2532 });
2533 try {
2534 enterOuterAlt(_localctx, 1);
2535 setState(314);
2536 match(OMDParser::BEND);
2537 setState(319);
2538 _errHandler->sync(this);
2539
2540 _la = _input->LA(1);
2541 if (_la == OMDParser::LBRACKET) {
2542 setState(315);
2543 match(OMDParser::LBRACKET);
2544 setState(316);
2545 intConst();
2546 setState(317);
2547 match(OMDParser::RBRACKET);
2548 }
2549 setState(321);
2550 match(OMDParser::LCURLY);
2551 setState(325);
2552 _errHandler->sync(this);
2553 _la = _input->LA(1);
2554 while (((((_la - 18) & ~ 0x3fULL) == 0) &&
2555 ((1ULL << (_la - 18)) & 140737488844801) != 0)) {
2556 setState(322);
2557 bendstatement();
2558 setState(327);
2559 _errHandler->sync(this);
2560 _la = _input->LA(1);
2561 }
2562 setState(328);
2563 match(OMDParser::RCURLY);
2564
2565 }
2566 catch (RecognitionException &e) {
2567 _errHandler->reportError(this, e);
2568 _localctx->exception = std::current_exception();
2569 _errHandler->recover(this, _localctx->exception);
2570 }
2571
2572 return _localctx;
2573}
2574
2575//----------------- BendstatementContext ------------------------------------------------------------------
2576
2577OMDParser::BendstatementContext::BendstatementContext(ParserRuleContext *parent, size_t invokingState)
2578 : ParserRuleContext(parent, invokingState) {
2579}
2580
2581OMDParser::AssignmentContext* OMDParser::BendstatementContext::assignment() {
2582 return getRuleContext<OMDParser::AssignmentContext>(0);
2583}
2584
2585tree::TerminalNode* OMDParser::BendstatementContext::MEMBERS() {
2586 return getToken(OMDParser::MEMBERS, 0);
2587}
2588
2589tree::TerminalNode* OMDParser::BendstatementContext::LPAREN() {
2590 return getToken(OMDParser::LPAREN, 0);
2591}
2592
2593OMDParser::InttupleContext* OMDParser::BendstatementContext::inttuple() {
2594 return getRuleContext<OMDParser::InttupleContext>(0);
2595}
2596
2597tree::TerminalNode* OMDParser::BendstatementContext::RPAREN() {
2598 return getToken(OMDParser::RPAREN, 0);
2599}
2600
2601tree::TerminalNode* OMDParser::BendstatementContext::SEMICOLON() {
2602 return getToken(OMDParser::SEMICOLON, 0);
2603}
2604
2605tree::TerminalNode* OMDParser::BendstatementContext::HARMONIC() {
2606 return getToken(OMDParser::HARMONIC, 0);
2607}
2608
2609OMDParser::DoubleNumberTupleContext* OMDParser::BendstatementContext::doubleNumberTuple() {
2610 return getRuleContext<OMDParser::DoubleNumberTupleContext>(0);
2611}
2612
2613tree::TerminalNode* OMDParser::BendstatementContext::GHOSTBEND() {
2614 return getToken(OMDParser::GHOSTBEND, 0);
2615}
2616
2617tree::TerminalNode* OMDParser::BendstatementContext::UREYBRADLEY() {
2618 return getToken(OMDParser::UREYBRADLEY, 0);
2619}
2620
2621tree::TerminalNode* OMDParser::BendstatementContext::CUBIC() {
2622 return getToken(OMDParser::CUBIC, 0);
2623}
2624
2625tree::TerminalNode* OMDParser::BendstatementContext::QUARTIC() {
2626 return getToken(OMDParser::QUARTIC, 0);
2627}
2628
2629tree::TerminalNode* OMDParser::BendstatementContext::POLYNOMIAL() {
2630 return getToken(OMDParser::POLYNOMIAL, 0);
2631}
2632
2633tree::TerminalNode* OMDParser::BendstatementContext::COSINE() {
2634 return getToken(OMDParser::COSINE, 0);
2635}
2636
2637
2638size_t OMDParser::BendstatementContext::getRuleIndex() const {
2639 return OMDParser::RuleBendstatement;
2640}
2641
2642void OMDParser::BendstatementContext::enterRule(tree::ParseTreeListener *listener) {
2643 auto parserListener = dynamic_cast<OMDListener *>(listener);
2644 if (parserListener != nullptr)
2645 parserListener->enterBendstatement(this);
2646}
2647
2648void OMDParser::BendstatementContext::exitRule(tree::ParseTreeListener *listener) {
2649 auto parserListener = dynamic_cast<OMDListener *>(listener);
2650 if (parserListener != nullptr)
2651 parserListener->exitBendstatement(this);
2652}
2653
2654
2655std::any OMDParser::BendstatementContext::accept(tree::ParseTreeVisitor *visitor) {
2656 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
2657 return parserVisitor->visitBendstatement(this);
2658 else
2659 return visitor->visitChildren(this);
2660}
2661
2662OMDParser::BendstatementContext* OMDParser::bendstatement() {
2663 BendstatementContext *_localctx = _tracker.createInstance<BendstatementContext>(_ctx, getState());
2664 enterRule(_localctx, 38, OMDParser::RuleBendstatement);
2665
2666#if __cplusplus > 201703L
2667 auto onExit = finally([=, this] {
2668#else
2669 auto onExit = finally([=] {
2670#endif
2671 exitRule();
2672 });
2673 try {
2674 setState(379);
2675 _errHandler->sync(this);
2676 switch (_input->LA(1)) {
2677 case OMDParser::ID: {
2678 enterOuterAlt(_localctx, 1);
2679 setState(330);
2680 assignment();
2681 break;
2682 }
2683
2684 case OMDParser::MEMBERS: {
2685 enterOuterAlt(_localctx, 2);
2686 setState(331);
2687 match(OMDParser::MEMBERS);
2688 setState(332);
2689 match(OMDParser::LPAREN);
2690 setState(333);
2691 inttuple();
2692 setState(334);
2693 match(OMDParser::RPAREN);
2694 setState(335);
2695 match(OMDParser::SEMICOLON);
2696 break;
2697 }
2698
2699 case OMDParser::HARMONIC: {
2700 enterOuterAlt(_localctx, 3);
2701 setState(337);
2702 match(OMDParser::HARMONIC);
2703 setState(338);
2704 match(OMDParser::LPAREN);
2705 setState(339);
2706 doubleNumberTuple();
2707 setState(340);
2708 match(OMDParser::RPAREN);
2709 setState(341);
2710 match(OMDParser::SEMICOLON);
2711 break;
2712 }
2713
2714 case OMDParser::GHOSTBEND: {
2715 enterOuterAlt(_localctx, 4);
2716 setState(343);
2717 match(OMDParser::GHOSTBEND);
2718 setState(344);
2719 match(OMDParser::LPAREN);
2720 setState(345);
2721 doubleNumberTuple();
2722 setState(346);
2723 match(OMDParser::RPAREN);
2724 setState(347);
2725 match(OMDParser::SEMICOLON);
2726 break;
2727 }
2728
2729 case OMDParser::UREYBRADLEY: {
2730 enterOuterAlt(_localctx, 5);
2731 setState(349);
2732 match(OMDParser::UREYBRADLEY);
2733 setState(350);
2734 match(OMDParser::LPAREN);
2735 setState(351);
2736 doubleNumberTuple();
2737 setState(352);
2738 match(OMDParser::RPAREN);
2739 setState(353);
2740 match(OMDParser::SEMICOLON);
2741 break;
2742 }
2743
2744 case OMDParser::CUBIC: {
2745 enterOuterAlt(_localctx, 6);
2746 setState(355);
2747 match(OMDParser::CUBIC);
2748 setState(356);
2749 match(OMDParser::LPAREN);
2750 setState(357);
2751 doubleNumberTuple();
2752 setState(358);
2753 match(OMDParser::RPAREN);
2754 setState(359);
2755 match(OMDParser::SEMICOLON);
2756 break;
2757 }
2758
2759 case OMDParser::QUARTIC: {
2760 enterOuterAlt(_localctx, 7);
2761 setState(361);
2762 match(OMDParser::QUARTIC);
2763 setState(362);
2764 match(OMDParser::LPAREN);
2765 setState(363);
2766 doubleNumberTuple();
2767 setState(364);
2768 match(OMDParser::RPAREN);
2769 setState(365);
2770 match(OMDParser::SEMICOLON);
2771 break;
2772 }
2773
2774 case OMDParser::POLYNOMIAL: {
2775 enterOuterAlt(_localctx, 8);
2776 setState(367);
2777 match(OMDParser::POLYNOMIAL);
2778 setState(368);
2779 match(OMDParser::LPAREN);
2780 setState(369);
2781 doubleNumberTuple();
2782 setState(370);
2783 match(OMDParser::RPAREN);
2784 setState(371);
2785 match(OMDParser::SEMICOLON);
2786 break;
2787 }
2788
2789 case OMDParser::COSINE: {
2790 enterOuterAlt(_localctx, 9);
2791 setState(373);
2792 match(OMDParser::COSINE);
2793 setState(374);
2794 match(OMDParser::LPAREN);
2795 setState(375);
2796 doubleNumberTuple();
2797 setState(376);
2798 match(OMDParser::RPAREN);
2799 setState(377);
2800 match(OMDParser::SEMICOLON);
2801 break;
2802 }
2803
2804 default:
2805 throw NoViableAltException(this);
2806 }
2807
2808 }
2809 catch (RecognitionException &e) {
2810 _errHandler->reportError(this, e);
2811 _localctx->exception = std::current_exception();
2812 _errHandler->recover(this, _localctx->exception);
2813 }
2814
2815 return _localctx;
2816}
2817
2818//----------------- TorsionblockContext ------------------------------------------------------------------
2819
2820OMDParser::TorsionblockContext::TorsionblockContext(ParserRuleContext *parent, size_t invokingState)
2821 : ParserRuleContext(parent, invokingState) {
2822}
2823
2824tree::TerminalNode* OMDParser::TorsionblockContext::TORSION() {
2825 return getToken(OMDParser::TORSION, 0);
2826}
2827
2828tree::TerminalNode* OMDParser::TorsionblockContext::LCURLY() {
2829 return getToken(OMDParser::LCURLY, 0);
2830}
2831
2832tree::TerminalNode* OMDParser::TorsionblockContext::RCURLY() {
2833 return getToken(OMDParser::RCURLY, 0);
2834}
2835
2836tree::TerminalNode* OMDParser::TorsionblockContext::LBRACKET() {
2837 return getToken(OMDParser::LBRACKET, 0);
2838}
2839
2840OMDParser::IntConstContext* OMDParser::TorsionblockContext::intConst() {
2841 return getRuleContext<OMDParser::IntConstContext>(0);
2842}
2843
2844tree::TerminalNode* OMDParser::TorsionblockContext::RBRACKET() {
2845 return getToken(OMDParser::RBRACKET, 0);
2846}
2847
2848std::vector<OMDParser::TorsionstatementContext *> OMDParser::TorsionblockContext::torsionstatement() {
2849 return getRuleContexts<OMDParser::TorsionstatementContext>();
2850}
2851
2852OMDParser::TorsionstatementContext* OMDParser::TorsionblockContext::torsionstatement(size_t i) {
2853 return getRuleContext<OMDParser::TorsionstatementContext>(i);
2854}
2855
2856
2857size_t OMDParser::TorsionblockContext::getRuleIndex() const {
2858 return OMDParser::RuleTorsionblock;
2859}
2860
2861void OMDParser::TorsionblockContext::enterRule(tree::ParseTreeListener *listener) {
2862 auto parserListener = dynamic_cast<OMDListener *>(listener);
2863 if (parserListener != nullptr)
2864 parserListener->enterTorsionblock(this);
2865}
2866
2867void OMDParser::TorsionblockContext::exitRule(tree::ParseTreeListener *listener) {
2868 auto parserListener = dynamic_cast<OMDListener *>(listener);
2869 if (parserListener != nullptr)
2870 parserListener->exitTorsionblock(this);
2871}
2872
2873
2874std::any OMDParser::TorsionblockContext::accept(tree::ParseTreeVisitor *visitor) {
2875 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
2876 return parserVisitor->visitTorsionblock(this);
2877 else
2878 return visitor->visitChildren(this);
2879}
2880
2881OMDParser::TorsionblockContext* OMDParser::torsionblock() {
2882 TorsionblockContext *_localctx = _tracker.createInstance<TorsionblockContext>(_ctx, getState());
2883 enterRule(_localctx, 40, OMDParser::RuleTorsionblock);
2884 size_t _la = 0;
2885
2886#if __cplusplus > 201703L
2887 auto onExit = finally([=, this] {
2888#else
2889 auto onExit = finally([=] {
2890#endif
2891 exitRule();
2892 });
2893 try {
2894 enterOuterAlt(_localctx, 1);
2895 setState(381);
2896 match(OMDParser::TORSION);
2897 setState(386);
2898 _errHandler->sync(this);
2899
2900 _la = _input->LA(1);
2901 if (_la == OMDParser::LBRACKET) {
2902 setState(382);
2903 match(OMDParser::LBRACKET);
2904 setState(383);
2905 intConst();
2906 setState(384);
2907 match(OMDParser::RBRACKET);
2908 }
2909 setState(388);
2910 match(OMDParser::LCURLY);
2911 setState(392);
2912 _errHandler->sync(this);
2913 _la = _input->LA(1);
2914 while (((((_la - 18) & ~ 0x3fULL) == 0) &&
2915 ((1ULL << (_la - 18)) & 140737496250369) != 0)) {
2916 setState(389);
2917 torsionstatement();
2918 setState(394);
2919 _errHandler->sync(this);
2920 _la = _input->LA(1);
2921 }
2922 setState(395);
2923 match(OMDParser::RCURLY);
2924
2925 }
2926 catch (RecognitionException &e) {
2927 _errHandler->reportError(this, e);
2928 _localctx->exception = std::current_exception();
2929 _errHandler->recover(this, _localctx->exception);
2930 }
2931
2932 return _localctx;
2933}
2934
2935//----------------- TorsionstatementContext ------------------------------------------------------------------
2936
2937OMDParser::TorsionstatementContext::TorsionstatementContext(ParserRuleContext *parent, size_t invokingState)
2938 : ParserRuleContext(parent, invokingState) {
2939}
2940
2941OMDParser::AssignmentContext* OMDParser::TorsionstatementContext::assignment() {
2942 return getRuleContext<OMDParser::AssignmentContext>(0);
2943}
2944
2945tree::TerminalNode* OMDParser::TorsionstatementContext::MEMBERS() {
2946 return getToken(OMDParser::MEMBERS, 0);
2947}
2948
2949tree::TerminalNode* OMDParser::TorsionstatementContext::LPAREN() {
2950 return getToken(OMDParser::LPAREN, 0);
2951}
2952
2953OMDParser::InttupleContext* OMDParser::TorsionstatementContext::inttuple() {
2954 return getRuleContext<OMDParser::InttupleContext>(0);
2955}
2956
2957tree::TerminalNode* OMDParser::TorsionstatementContext::RPAREN() {
2958 return getToken(OMDParser::RPAREN, 0);
2959}
2960
2961tree::TerminalNode* OMDParser::TorsionstatementContext::SEMICOLON() {
2962 return getToken(OMDParser::SEMICOLON, 0);
2963}
2964
2965tree::TerminalNode* OMDParser::TorsionstatementContext::GHOSTTORSION() {
2966 return getToken(OMDParser::GHOSTTORSION, 0);
2967}
2968
2969OMDParser::DoubleNumberTupleContext* OMDParser::TorsionstatementContext::doubleNumberTuple() {
2970 return getRuleContext<OMDParser::DoubleNumberTupleContext>(0);
2971}
2972
2973tree::TerminalNode* OMDParser::TorsionstatementContext::CUBIC() {
2974 return getToken(OMDParser::CUBIC, 0);
2975}
2976
2977tree::TerminalNode* OMDParser::TorsionstatementContext::QUARTIC() {
2978 return getToken(OMDParser::QUARTIC, 0);
2979}
2980
2981tree::TerminalNode* OMDParser::TorsionstatementContext::POLYNOMIAL() {
2982 return getToken(OMDParser::POLYNOMIAL, 0);
2983}
2984
2985tree::TerminalNode* OMDParser::TorsionstatementContext::CHARMM() {
2986 return getToken(OMDParser::CHARMM, 0);
2987}
2988
2989tree::TerminalNode* OMDParser::TorsionstatementContext::OPLS() {
2990 return getToken(OMDParser::OPLS, 0);
2991}
2992
2993tree::TerminalNode* OMDParser::TorsionstatementContext::TRAPPE() {
2994 return getToken(OMDParser::TRAPPE, 0);
2995}
2996
2997tree::TerminalNode* OMDParser::TorsionstatementContext::HARMONIC() {
2998 return getToken(OMDParser::HARMONIC, 0);
2999}
3000
3001
3002size_t OMDParser::TorsionstatementContext::getRuleIndex() const {
3003 return OMDParser::RuleTorsionstatement;
3004}
3005
3006void OMDParser::TorsionstatementContext::enterRule(tree::ParseTreeListener *listener) {
3007 auto parserListener = dynamic_cast<OMDListener *>(listener);
3008 if (parserListener != nullptr)
3009 parserListener->enterTorsionstatement(this);
3010}
3011
3012void OMDParser::TorsionstatementContext::exitRule(tree::ParseTreeListener *listener) {
3013 auto parserListener = dynamic_cast<OMDListener *>(listener);
3014 if (parserListener != nullptr)
3015 parserListener->exitTorsionstatement(this);
3016}
3017
3018
3019std::any OMDParser::TorsionstatementContext::accept(tree::ParseTreeVisitor *visitor) {
3020 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
3021 return parserVisitor->visitTorsionstatement(this);
3022 else
3023 return visitor->visitChildren(this);
3024}
3025
3026OMDParser::TorsionstatementContext* OMDParser::torsionstatement() {
3027 TorsionstatementContext *_localctx = _tracker.createInstance<TorsionstatementContext>(_ctx, getState());
3028 enterRule(_localctx, 42, OMDParser::RuleTorsionstatement);
3029
3030#if __cplusplus > 201703L
3031 auto onExit = finally([=, this] {
3032#else
3033 auto onExit = finally([=] {
3034#endif
3035 exitRule();
3036 });
3037 try {
3038 setState(452);
3039 _errHandler->sync(this);
3040 switch (_input->LA(1)) {
3041 case OMDParser::ID: {
3042 enterOuterAlt(_localctx, 1);
3043 setState(397);
3044 assignment();
3045 break;
3046 }
3047
3048 case OMDParser::MEMBERS: {
3049 enterOuterAlt(_localctx, 2);
3050 setState(398);
3051 match(OMDParser::MEMBERS);
3052 setState(399);
3053 match(OMDParser::LPAREN);
3054 setState(400);
3055 inttuple();
3056 setState(401);
3057 match(OMDParser::RPAREN);
3058 setState(402);
3059 match(OMDParser::SEMICOLON);
3060 break;
3061 }
3062
3063 case OMDParser::GHOSTTORSION: {
3064 enterOuterAlt(_localctx, 3);
3065 setState(404);
3066 match(OMDParser::GHOSTTORSION);
3067 setState(405);
3068 match(OMDParser::LPAREN);
3069 setState(406);
3070 doubleNumberTuple();
3071 setState(407);
3072 match(OMDParser::RPAREN);
3073 setState(408);
3074 match(OMDParser::SEMICOLON);
3075 break;
3076 }
3077
3078 case OMDParser::CUBIC: {
3079 enterOuterAlt(_localctx, 4);
3080 setState(410);
3081 match(OMDParser::CUBIC);
3082 setState(411);
3083 match(OMDParser::LPAREN);
3084 setState(412);
3085 doubleNumberTuple();
3086 setState(413);
3087 match(OMDParser::RPAREN);
3088 setState(414);
3089 match(OMDParser::SEMICOLON);
3090 break;
3091 }
3092
3093 case OMDParser::QUARTIC: {
3094 enterOuterAlt(_localctx, 5);
3095 setState(416);
3096 match(OMDParser::QUARTIC);
3097 setState(417);
3098 match(OMDParser::LPAREN);
3099 setState(418);
3100 doubleNumberTuple();
3101 setState(419);
3102 match(OMDParser::RPAREN);
3103 setState(420);
3104 match(OMDParser::SEMICOLON);
3105 break;
3106 }
3107
3108 case OMDParser::POLYNOMIAL: {
3109 enterOuterAlt(_localctx, 6);
3110 setState(422);
3111 match(OMDParser::POLYNOMIAL);
3112 setState(423);
3113 match(OMDParser::LPAREN);
3114 setState(424);
3115 doubleNumberTuple();
3116 setState(425);
3117 match(OMDParser::RPAREN);
3118 setState(426);
3119 match(OMDParser::SEMICOLON);
3120 break;
3121 }
3122
3123 case OMDParser::CHARMM: {
3124 enterOuterAlt(_localctx, 7);
3125 setState(428);
3126 match(OMDParser::CHARMM);
3127 setState(429);
3128 match(OMDParser::LPAREN);
3129 setState(430);
3130 doubleNumberTuple();
3131 setState(431);
3132 match(OMDParser::RPAREN);
3133 setState(432);
3134 match(OMDParser::SEMICOLON);
3135 break;
3136 }
3137
3138 case OMDParser::OPLS: {
3139 enterOuterAlt(_localctx, 8);
3140 setState(434);
3141 match(OMDParser::OPLS);
3142 setState(435);
3143 match(OMDParser::LPAREN);
3144 setState(436);
3145 doubleNumberTuple();
3146 setState(437);
3147 match(OMDParser::RPAREN);
3148 setState(438);
3149 match(OMDParser::SEMICOLON);
3150 break;
3151 }
3152
3153 case OMDParser::TRAPPE: {
3154 enterOuterAlt(_localctx, 9);
3155 setState(440);
3156 match(OMDParser::TRAPPE);
3157 setState(441);
3158 match(OMDParser::LPAREN);
3159 setState(442);
3160 doubleNumberTuple();
3161 setState(443);
3162 match(OMDParser::RPAREN);
3163 setState(444);
3164 match(OMDParser::SEMICOLON);
3165 break;
3166 }
3167
3168 case OMDParser::HARMONIC: {
3169 enterOuterAlt(_localctx, 10);
3170 setState(446);
3171 match(OMDParser::HARMONIC);
3172 setState(447);
3173 match(OMDParser::LPAREN);
3174 setState(448);
3175 doubleNumberTuple();
3176 setState(449);
3177 match(OMDParser::RPAREN);
3178 setState(450);
3179 match(OMDParser::SEMICOLON);
3180 break;
3181 }
3182
3183 default:
3184 throw NoViableAltException(this);
3185 }
3186
3187 }
3188 catch (RecognitionException &e) {
3189 _errHandler->reportError(this, e);
3190 _localctx->exception = std::current_exception();
3191 _errHandler->recover(this, _localctx->exception);
3192 }
3193
3194 return _localctx;
3195}
3196
3197//----------------- InversionblockContext ------------------------------------------------------------------
3198
3199OMDParser::InversionblockContext::InversionblockContext(ParserRuleContext *parent, size_t invokingState)
3200 : ParserRuleContext(parent, invokingState) {
3201}
3202
3203tree::TerminalNode* OMDParser::InversionblockContext::INVERSION() {
3204 return getToken(OMDParser::INVERSION, 0);
3205}
3206
3207tree::TerminalNode* OMDParser::InversionblockContext::LCURLY() {
3208 return getToken(OMDParser::LCURLY, 0);
3209}
3210
3211tree::TerminalNode* OMDParser::InversionblockContext::RCURLY() {
3212 return getToken(OMDParser::RCURLY, 0);
3213}
3214
3215tree::TerminalNode* OMDParser::InversionblockContext::LBRACKET() {
3216 return getToken(OMDParser::LBRACKET, 0);
3217}
3218
3219OMDParser::IntConstContext* OMDParser::InversionblockContext::intConst() {
3220 return getRuleContext<OMDParser::IntConstContext>(0);
3221}
3222
3223tree::TerminalNode* OMDParser::InversionblockContext::RBRACKET() {
3224 return getToken(OMDParser::RBRACKET, 0);
3225}
3226
3227std::vector<OMDParser::InversionstatementContext *> OMDParser::InversionblockContext::inversionstatement() {
3228 return getRuleContexts<OMDParser::InversionstatementContext>();
3229}
3230
3231OMDParser::InversionstatementContext* OMDParser::InversionblockContext::inversionstatement(size_t i) {
3232 return getRuleContext<OMDParser::InversionstatementContext>(i);
3233}
3234
3235
3236size_t OMDParser::InversionblockContext::getRuleIndex() const {
3237 return OMDParser::RuleInversionblock;
3238}
3239
3240void OMDParser::InversionblockContext::enterRule(tree::ParseTreeListener *listener) {
3241 auto parserListener = dynamic_cast<OMDListener *>(listener);
3242 if (parserListener != nullptr)
3243 parserListener->enterInversionblock(this);
3244}
3245
3246void OMDParser::InversionblockContext::exitRule(tree::ParseTreeListener *listener) {
3247 auto parserListener = dynamic_cast<OMDListener *>(listener);
3248 if (parserListener != nullptr)
3249 parserListener->exitInversionblock(this);
3250}
3251
3252
3253std::any OMDParser::InversionblockContext::accept(tree::ParseTreeVisitor *visitor) {
3254 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
3255 return parserVisitor->visitInversionblock(this);
3256 else
3257 return visitor->visitChildren(this);
3258}
3259
3260OMDParser::InversionblockContext* OMDParser::inversionblock() {
3261 InversionblockContext *_localctx = _tracker.createInstance<InversionblockContext>(_ctx, getState());
3262 enterRule(_localctx, 44, OMDParser::RuleInversionblock);
3263 size_t _la = 0;
3264
3265#if __cplusplus > 201703L
3266 auto onExit = finally([=, this] {
3267#else
3268 auto onExit = finally([=] {
3269#endif
3270 exitRule();
3271 });
3272 try {
3273 enterOuterAlt(_localctx, 1);
3274 setState(454);
3275 match(OMDParser::INVERSION);
3276 setState(459);
3277 _errHandler->sync(this);
3278
3279 _la = _input->LA(1);
3280 if (_la == OMDParser::LBRACKET) {
3281 setState(455);
3282 match(OMDParser::LBRACKET);
3283 setState(456);
3284 intConst();
3285 setState(457);
3286 match(OMDParser::RBRACKET);
3287 }
3288 setState(461);
3289 match(OMDParser::LCURLY);
3290 setState(465);
3291 _errHandler->sync(this);
3292 _la = _input->LA(1);
3293 while (((((_la - 19) & ~ 0x3fULL) == 0) &&
3294 ((1ULL << (_la - 19)) & 70368807093251) != 0)) {
3295 setState(462);
3296 inversionstatement();
3297 setState(467);
3298 _errHandler->sync(this);
3299 _la = _input->LA(1);
3300 }
3301 setState(468);
3302 match(OMDParser::RCURLY);
3303
3304 }
3305 catch (RecognitionException &e) {
3306 _errHandler->reportError(this, e);
3307 _localctx->exception = std::current_exception();
3308 _errHandler->recover(this, _localctx->exception);
3309 }
3310
3311 return _localctx;
3312}
3313
3314//----------------- InversionstatementContext ------------------------------------------------------------------
3315
3316OMDParser::InversionstatementContext::InversionstatementContext(ParserRuleContext *parent, size_t invokingState)
3317 : ParserRuleContext(parent, invokingState) {
3318}
3319
3320OMDParser::AssignmentContext* OMDParser::InversionstatementContext::assignment() {
3321 return getRuleContext<OMDParser::AssignmentContext>(0);
3322}
3323
3324tree::TerminalNode* OMDParser::InversionstatementContext::CENTER() {
3325 return getToken(OMDParser::CENTER, 0);
3326}
3327
3328tree::TerminalNode* OMDParser::InversionstatementContext::LPAREN() {
3329 return getToken(OMDParser::LPAREN, 0);
3330}
3331
3332OMDParser::IntConstContext* OMDParser::InversionstatementContext::intConst() {
3333 return getRuleContext<OMDParser::IntConstContext>(0);
3334}
3335
3336tree::TerminalNode* OMDParser::InversionstatementContext::RPAREN() {
3337 return getToken(OMDParser::RPAREN, 0);
3338}
3339
3340tree::TerminalNode* OMDParser::InversionstatementContext::SEMICOLON() {
3341 return getToken(OMDParser::SEMICOLON, 0);
3342}
3343
3344tree::TerminalNode* OMDParser::InversionstatementContext::SATELLITES() {
3345 return getToken(OMDParser::SATELLITES, 0);
3346}
3347
3348OMDParser::InttupleContext* OMDParser::InversionstatementContext::inttuple() {
3349 return getRuleContext<OMDParser::InttupleContext>(0);
3350}
3351
3352tree::TerminalNode* OMDParser::InversionstatementContext::AMBERIMPROPER() {
3353 return getToken(OMDParser::AMBERIMPROPER, 0);
3354}
3355
3356OMDParser::DoubleNumberTupleContext* OMDParser::InversionstatementContext::doubleNumberTuple() {
3357 return getRuleContext<OMDParser::DoubleNumberTupleContext>(0);
3358}
3359
3360tree::TerminalNode* OMDParser::InversionstatementContext::IMPROPERCOSINE() {
3361 return getToken(OMDParser::IMPROPERCOSINE, 0);
3362}
3363
3364tree::TerminalNode* OMDParser::InversionstatementContext::HARMONIC() {
3365 return getToken(OMDParser::HARMONIC, 0);
3366}
3367
3368tree::TerminalNode* OMDParser::InversionstatementContext::CENTRALATOMHEIGHT() {
3369 return getToken(OMDParser::CENTRALATOMHEIGHT, 0);
3370}
3371
3372tree::TerminalNode* OMDParser::InversionstatementContext::DREIDING() {
3373 return getToken(OMDParser::DREIDING, 0);
3374}
3375
3376
3377size_t OMDParser::InversionstatementContext::getRuleIndex() const {
3378 return OMDParser::RuleInversionstatement;
3379}
3380
3381void OMDParser::InversionstatementContext::enterRule(tree::ParseTreeListener *listener) {
3382 auto parserListener = dynamic_cast<OMDListener *>(listener);
3383 if (parserListener != nullptr)
3384 parserListener->enterInversionstatement(this);
3385}
3386
3387void OMDParser::InversionstatementContext::exitRule(tree::ParseTreeListener *listener) {
3388 auto parserListener = dynamic_cast<OMDListener *>(listener);
3389 if (parserListener != nullptr)
3390 parserListener->exitInversionstatement(this);
3391}
3392
3393
3394std::any OMDParser::InversionstatementContext::accept(tree::ParseTreeVisitor *visitor) {
3395 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
3396 return parserVisitor->visitInversionstatement(this);
3397 else
3398 return visitor->visitChildren(this);
3399}
3400
3401OMDParser::InversionstatementContext* OMDParser::inversionstatement() {
3402 InversionstatementContext *_localctx = _tracker.createInstance<InversionstatementContext>(_ctx, getState());
3403 enterRule(_localctx, 46, OMDParser::RuleInversionstatement);
3404
3405#if __cplusplus > 201703L
3406 auto onExit = finally([=, this] {
3407#else
3408 auto onExit = finally([=] {
3409#endif
3410 exitRule();
3411 });
3412 try {
3413 setState(513);
3414 _errHandler->sync(this);
3415 switch (_input->LA(1)) {
3416 case OMDParser::ID: {
3417 enterOuterAlt(_localctx, 1);
3418 setState(470);
3419 assignment();
3420 break;
3421 }
3422
3423 case OMDParser::CENTER: {
3424 enterOuterAlt(_localctx, 2);
3425 setState(471);
3426 match(OMDParser::CENTER);
3427 setState(472);
3428 match(OMDParser::LPAREN);
3429 setState(473);
3430 intConst();
3431 setState(474);
3432 match(OMDParser::RPAREN);
3433 setState(475);
3434 match(OMDParser::SEMICOLON);
3435 break;
3436 }
3437
3438 case OMDParser::SATELLITES: {
3439 enterOuterAlt(_localctx, 3);
3440 setState(477);
3441 match(OMDParser::SATELLITES);
3442 setState(478);
3443 match(OMDParser::LPAREN);
3444 setState(479);
3445 inttuple();
3446 setState(480);
3447 match(OMDParser::RPAREN);
3448 setState(481);
3449 match(OMDParser::SEMICOLON);
3450 break;
3451 }
3452
3453 case OMDParser::AMBERIMPROPER: {
3454 enterOuterAlt(_localctx, 4);
3455 setState(483);
3456 match(OMDParser::AMBERIMPROPER);
3457 setState(484);
3458 match(OMDParser::LPAREN);
3459 setState(485);
3460 doubleNumberTuple();
3461 setState(486);
3462 match(OMDParser::RPAREN);
3463 setState(487);
3464 match(OMDParser::SEMICOLON);
3465 break;
3466 }
3467
3468 case OMDParser::IMPROPERCOSINE: {
3469 enterOuterAlt(_localctx, 5);
3470 setState(489);
3471 match(OMDParser::IMPROPERCOSINE);
3472 setState(490);
3473 match(OMDParser::LPAREN);
3474 setState(491);
3475 doubleNumberTuple();
3476 setState(492);
3477 match(OMDParser::RPAREN);
3478 setState(493);
3479 match(OMDParser::SEMICOLON);
3480 break;
3481 }
3482
3483 case OMDParser::HARMONIC: {
3484 enterOuterAlt(_localctx, 6);
3485 setState(495);
3486 match(OMDParser::HARMONIC);
3487 setState(496);
3488 match(OMDParser::LPAREN);
3489 setState(497);
3490 doubleNumberTuple();
3491 setState(498);
3492 match(OMDParser::RPAREN);
3493 setState(499);
3494 match(OMDParser::SEMICOLON);
3495 break;
3496 }
3497
3498 case OMDParser::CENTRALATOMHEIGHT: {
3499 enterOuterAlt(_localctx, 7);
3500 setState(501);
3501 match(OMDParser::CENTRALATOMHEIGHT);
3502 setState(502);
3503 match(OMDParser::LPAREN);
3504 setState(503);
3505 doubleNumberTuple();
3506 setState(504);
3507 match(OMDParser::RPAREN);
3508 setState(505);
3509 match(OMDParser::SEMICOLON);
3510 break;
3511 }
3512
3513 case OMDParser::DREIDING: {
3514 enterOuterAlt(_localctx, 8);
3515 setState(507);
3516 match(OMDParser::DREIDING);
3517 setState(508);
3518 match(OMDParser::LPAREN);
3519 setState(509);
3520 doubleNumberTuple();
3521 setState(510);
3522 match(OMDParser::RPAREN);
3523 setState(511);
3524 match(OMDParser::SEMICOLON);
3525 break;
3526 }
3527
3528 default:
3529 throw NoViableAltException(this);
3530 }
3531
3532 }
3533 catch (RecognitionException &e) {
3534 _errHandler->reportError(this, e);
3535 _localctx->exception = std::current_exception();
3536 _errHandler->recover(this, _localctx->exception);
3537 }
3538
3539 return _localctx;
3540}
3541
3542//----------------- RigidbodyblockContext ------------------------------------------------------------------
3543
3544OMDParser::RigidbodyblockContext::RigidbodyblockContext(ParserRuleContext *parent, size_t invokingState)
3545 : ParserRuleContext(parent, invokingState) {
3546}
3547
3548tree::TerminalNode* OMDParser::RigidbodyblockContext::RIGIDBODY() {
3549 return getToken(OMDParser::RIGIDBODY, 0);
3550}
3551
3552tree::TerminalNode* OMDParser::RigidbodyblockContext::LBRACKET() {
3553 return getToken(OMDParser::LBRACKET, 0);
3554}
3555
3556OMDParser::IntConstContext* OMDParser::RigidbodyblockContext::intConst() {
3557 return getRuleContext<OMDParser::IntConstContext>(0);
3558}
3559
3560tree::TerminalNode* OMDParser::RigidbodyblockContext::RBRACKET() {
3561 return getToken(OMDParser::RBRACKET, 0);
3562}
3563
3564tree::TerminalNode* OMDParser::RigidbodyblockContext::LCURLY() {
3565 return getToken(OMDParser::LCURLY, 0);
3566}
3567
3568tree::TerminalNode* OMDParser::RigidbodyblockContext::RCURLY() {
3569 return getToken(OMDParser::RCURLY, 0);
3570}
3571
3572std::vector<OMDParser::RigidbodystatementContext *> OMDParser::RigidbodyblockContext::rigidbodystatement() {
3573 return getRuleContexts<OMDParser::RigidbodystatementContext>();
3574}
3575
3576OMDParser::RigidbodystatementContext* OMDParser::RigidbodyblockContext::rigidbodystatement(size_t i) {
3577 return getRuleContext<OMDParser::RigidbodystatementContext>(i);
3578}
3579
3580
3581size_t OMDParser::RigidbodyblockContext::getRuleIndex() const {
3582 return OMDParser::RuleRigidbodyblock;
3583}
3584
3585void OMDParser::RigidbodyblockContext::enterRule(tree::ParseTreeListener *listener) {
3586 auto parserListener = dynamic_cast<OMDListener *>(listener);
3587 if (parserListener != nullptr)
3588 parserListener->enterRigidbodyblock(this);
3589}
3590
3591void OMDParser::RigidbodyblockContext::exitRule(tree::ParseTreeListener *listener) {
3592 auto parserListener = dynamic_cast<OMDListener *>(listener);
3593 if (parserListener != nullptr)
3594 parserListener->exitRigidbodyblock(this);
3595}
3596
3597
3598std::any OMDParser::RigidbodyblockContext::accept(tree::ParseTreeVisitor *visitor) {
3599 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
3600 return parserVisitor->visitRigidbodyblock(this);
3601 else
3602 return visitor->visitChildren(this);
3603}
3604
3605OMDParser::RigidbodyblockContext* OMDParser::rigidbodyblock() {
3606 RigidbodyblockContext *_localctx = _tracker.createInstance<RigidbodyblockContext>(_ctx, getState());
3607 enterRule(_localctx, 48, OMDParser::RuleRigidbodyblock);
3608 size_t _la = 0;
3609
3610#if __cplusplus > 201703L
3611 auto onExit = finally([=, this] {
3612#else
3613 auto onExit = finally([=] {
3614#endif
3615 exitRule();
3616 });
3617 try {
3618 enterOuterAlt(_localctx, 1);
3619 setState(515);
3620 match(OMDParser::RIGIDBODY);
3621 setState(516);
3622 match(OMDParser::LBRACKET);
3623 setState(517);
3624 intConst();
3625 setState(518);
3626 match(OMDParser::RBRACKET);
3627 setState(519);
3628 match(OMDParser::LCURLY);
3629 setState(523);
3630 _errHandler->sync(this);
3631 _la = _input->LA(1);
3632 while (_la == OMDParser::MEMBERS
3633
3634 || _la == OMDParser::ID) {
3635 setState(520);
3636 rigidbodystatement();
3637 setState(525);
3638 _errHandler->sync(this);
3639 _la = _input->LA(1);
3640 }
3641 setState(526);
3642 match(OMDParser::RCURLY);
3643
3644 }
3645 catch (RecognitionException &e) {
3646 _errHandler->reportError(this, e);
3647 _localctx->exception = std::current_exception();
3648 _errHandler->recover(this, _localctx->exception);
3649 }
3650
3651 return _localctx;
3652}
3653
3654//----------------- RigidbodystatementContext ------------------------------------------------------------------
3655
3656OMDParser::RigidbodystatementContext::RigidbodystatementContext(ParserRuleContext *parent, size_t invokingState)
3657 : ParserRuleContext(parent, invokingState) {
3658}
3659
3660OMDParser::AssignmentContext* OMDParser::RigidbodystatementContext::assignment() {
3661 return getRuleContext<OMDParser::AssignmentContext>(0);
3662}
3663
3664tree::TerminalNode* OMDParser::RigidbodystatementContext::MEMBERS() {
3665 return getToken(OMDParser::MEMBERS, 0);
3666}
3667
3668tree::TerminalNode* OMDParser::RigidbodystatementContext::LPAREN() {
3669 return getToken(OMDParser::LPAREN, 0);
3670}
3671
3672OMDParser::InttupleContext* OMDParser::RigidbodystatementContext::inttuple() {
3673 return getRuleContext<OMDParser::InttupleContext>(0);
3674}
3675
3676tree::TerminalNode* OMDParser::RigidbodystatementContext::RPAREN() {
3677 return getToken(OMDParser::RPAREN, 0);
3678}
3679
3680tree::TerminalNode* OMDParser::RigidbodystatementContext::SEMICOLON() {
3681 return getToken(OMDParser::SEMICOLON, 0);
3682}
3683
3684
3685size_t OMDParser::RigidbodystatementContext::getRuleIndex() const {
3686 return OMDParser::RuleRigidbodystatement;
3687}
3688
3689void OMDParser::RigidbodystatementContext::enterRule(tree::ParseTreeListener *listener) {
3690 auto parserListener = dynamic_cast<OMDListener *>(listener);
3691 if (parserListener != nullptr)
3692 parserListener->enterRigidbodystatement(this);
3693}
3694
3695void OMDParser::RigidbodystatementContext::exitRule(tree::ParseTreeListener *listener) {
3696 auto parserListener = dynamic_cast<OMDListener *>(listener);
3697 if (parserListener != nullptr)
3698 parserListener->exitRigidbodystatement(this);
3699}
3700
3701
3702std::any OMDParser::RigidbodystatementContext::accept(tree::ParseTreeVisitor *visitor) {
3703 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
3704 return parserVisitor->visitRigidbodystatement(this);
3705 else
3706 return visitor->visitChildren(this);
3707}
3708
3709OMDParser::RigidbodystatementContext* OMDParser::rigidbodystatement() {
3710 RigidbodystatementContext *_localctx = _tracker.createInstance<RigidbodystatementContext>(_ctx, getState());
3711 enterRule(_localctx, 50, OMDParser::RuleRigidbodystatement);
3712
3713#if __cplusplus > 201703L
3714 auto onExit = finally([=, this] {
3715#else
3716 auto onExit = finally([=] {
3717#endif
3718 exitRule();
3719 });
3720 try {
3721 setState(535);
3722 _errHandler->sync(this);
3723 switch (_input->LA(1)) {
3724 case OMDParser::ID: {
3725 enterOuterAlt(_localctx, 1);
3726 setState(528);
3727 assignment();
3728 break;
3729 }
3730
3731 case OMDParser::MEMBERS: {
3732 enterOuterAlt(_localctx, 2);
3733 setState(529);
3734 match(OMDParser::MEMBERS);
3735 setState(530);
3736 match(OMDParser::LPAREN);
3737 setState(531);
3738 inttuple();
3739 setState(532);
3740 match(OMDParser::RPAREN);
3741 setState(533);
3742 match(OMDParser::SEMICOLON);
3743 break;
3744 }
3745
3746 default:
3747 throw NoViableAltException(this);
3748 }
3749
3750 }
3751 catch (RecognitionException &e) {
3752 _errHandler->reportError(this, e);
3753 _localctx->exception = std::current_exception();
3754 _errHandler->recover(this, _localctx->exception);
3755 }
3756
3757 return _localctx;
3758}
3759
3760//----------------- CutoffgroupblockContext ------------------------------------------------------------------
3761
3762OMDParser::CutoffgroupblockContext::CutoffgroupblockContext(ParserRuleContext *parent, size_t invokingState)
3763 : ParserRuleContext(parent, invokingState) {
3764}
3765
3766tree::TerminalNode* OMDParser::CutoffgroupblockContext::CUTOFFGROUP() {
3767 return getToken(OMDParser::CUTOFFGROUP, 0);
3768}
3769
3770tree::TerminalNode* OMDParser::CutoffgroupblockContext::LCURLY() {
3771 return getToken(OMDParser::LCURLY, 0);
3772}
3773
3774tree::TerminalNode* OMDParser::CutoffgroupblockContext::RCURLY() {
3775 return getToken(OMDParser::RCURLY, 0);
3776}
3777
3778tree::TerminalNode* OMDParser::CutoffgroupblockContext::LBRACKET() {
3779 return getToken(OMDParser::LBRACKET, 0);
3780}
3781
3782OMDParser::IntConstContext* OMDParser::CutoffgroupblockContext::intConst() {
3783 return getRuleContext<OMDParser::IntConstContext>(0);
3784}
3785
3786tree::TerminalNode* OMDParser::CutoffgroupblockContext::RBRACKET() {
3787 return getToken(OMDParser::RBRACKET, 0);
3788}
3789
3790std::vector<OMDParser::CutoffgroupstatementContext *> OMDParser::CutoffgroupblockContext::cutoffgroupstatement() {
3791 return getRuleContexts<OMDParser::CutoffgroupstatementContext>();
3792}
3793
3794OMDParser::CutoffgroupstatementContext* OMDParser::CutoffgroupblockContext::cutoffgroupstatement(size_t i) {
3795 return getRuleContext<OMDParser::CutoffgroupstatementContext>(i);
3796}
3797
3798
3799size_t OMDParser::CutoffgroupblockContext::getRuleIndex() const {
3800 return OMDParser::RuleCutoffgroupblock;
3801}
3802
3803void OMDParser::CutoffgroupblockContext::enterRule(tree::ParseTreeListener *listener) {
3804 auto parserListener = dynamic_cast<OMDListener *>(listener);
3805 if (parserListener != nullptr)
3806 parserListener->enterCutoffgroupblock(this);
3807}
3808
3809void OMDParser::CutoffgroupblockContext::exitRule(tree::ParseTreeListener *listener) {
3810 auto parserListener = dynamic_cast<OMDListener *>(listener);
3811 if (parserListener != nullptr)
3812 parserListener->exitCutoffgroupblock(this);
3813}
3814
3815
3816std::any OMDParser::CutoffgroupblockContext::accept(tree::ParseTreeVisitor *visitor) {
3817 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
3818 return parserVisitor->visitCutoffgroupblock(this);
3819 else
3820 return visitor->visitChildren(this);
3821}
3822
3823OMDParser::CutoffgroupblockContext* OMDParser::cutoffgroupblock() {
3824 CutoffgroupblockContext *_localctx = _tracker.createInstance<CutoffgroupblockContext>(_ctx, getState());
3825 enterRule(_localctx, 52, OMDParser::RuleCutoffgroupblock);
3826 size_t _la = 0;
3827
3828#if __cplusplus > 201703L
3829 auto onExit = finally([=, this] {
3830#else
3831 auto onExit = finally([=] {
3832#endif
3833 exitRule();
3834 });
3835 try {
3836 enterOuterAlt(_localctx, 1);
3837 setState(537);
3838 match(OMDParser::CUTOFFGROUP);
3839 setState(542);
3840 _errHandler->sync(this);
3841
3842 _la = _input->LA(1);
3843 if (_la == OMDParser::LBRACKET) {
3844 setState(538);
3845 match(OMDParser::LBRACKET);
3846 setState(539);
3847 intConst();
3848 setState(540);
3849 match(OMDParser::RBRACKET);
3850 }
3851 setState(544);
3852 match(OMDParser::LCURLY);
3853 setState(548);
3854 _errHandler->sync(this);
3855 _la = _input->LA(1);
3856 while (_la == OMDParser::MEMBERS
3857
3858 || _la == OMDParser::ID) {
3859 setState(545);
3860 cutoffgroupstatement();
3861 setState(550);
3862 _errHandler->sync(this);
3863 _la = _input->LA(1);
3864 }
3865 setState(551);
3866 match(OMDParser::RCURLY);
3867
3868 }
3869 catch (RecognitionException &e) {
3870 _errHandler->reportError(this, e);
3871 _localctx->exception = std::current_exception();
3872 _errHandler->recover(this, _localctx->exception);
3873 }
3874
3875 return _localctx;
3876}
3877
3878//----------------- CutoffgroupstatementContext ------------------------------------------------------------------
3879
3880OMDParser::CutoffgroupstatementContext::CutoffgroupstatementContext(ParserRuleContext *parent, size_t invokingState)
3881 : ParserRuleContext(parent, invokingState) {
3882}
3883
3884OMDParser::AssignmentContext* OMDParser::CutoffgroupstatementContext::assignment() {
3885 return getRuleContext<OMDParser::AssignmentContext>(0);
3886}
3887
3888tree::TerminalNode* OMDParser::CutoffgroupstatementContext::MEMBERS() {
3889 return getToken(OMDParser::MEMBERS, 0);
3890}
3891
3892tree::TerminalNode* OMDParser::CutoffgroupstatementContext::LPAREN() {
3893 return getToken(OMDParser::LPAREN, 0);
3894}
3895
3896OMDParser::InttupleContext* OMDParser::CutoffgroupstatementContext::inttuple() {
3897 return getRuleContext<OMDParser::InttupleContext>(0);
3898}
3899
3900tree::TerminalNode* OMDParser::CutoffgroupstatementContext::RPAREN() {
3901 return getToken(OMDParser::RPAREN, 0);
3902}
3903
3904tree::TerminalNode* OMDParser::CutoffgroupstatementContext::SEMICOLON() {
3905 return getToken(OMDParser::SEMICOLON, 0);
3906}
3907
3908
3909size_t OMDParser::CutoffgroupstatementContext::getRuleIndex() const {
3910 return OMDParser::RuleCutoffgroupstatement;
3911}
3912
3913void OMDParser::CutoffgroupstatementContext::enterRule(tree::ParseTreeListener *listener) {
3914 auto parserListener = dynamic_cast<OMDListener *>(listener);
3915 if (parserListener != nullptr)
3916 parserListener->enterCutoffgroupstatement(this);
3917}
3918
3919void OMDParser::CutoffgroupstatementContext::exitRule(tree::ParseTreeListener *listener) {
3920 auto parserListener = dynamic_cast<OMDListener *>(listener);
3921 if (parserListener != nullptr)
3922 parserListener->exitCutoffgroupstatement(this);
3923}
3924
3925
3926std::any OMDParser::CutoffgroupstatementContext::accept(tree::ParseTreeVisitor *visitor) {
3927 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
3928 return parserVisitor->visitCutoffgroupstatement(this);
3929 else
3930 return visitor->visitChildren(this);
3931}
3932
3933OMDParser::CutoffgroupstatementContext* OMDParser::cutoffgroupstatement() {
3934 CutoffgroupstatementContext *_localctx = _tracker.createInstance<CutoffgroupstatementContext>(_ctx, getState());
3935 enterRule(_localctx, 54, OMDParser::RuleCutoffgroupstatement);
3936
3937#if __cplusplus > 201703L
3938 auto onExit = finally([=, this] {
3939#else
3940 auto onExit = finally([=] {
3941#endif
3942 exitRule();
3943 });
3944 try {
3945 setState(560);
3946 _errHandler->sync(this);
3947 switch (_input->LA(1)) {
3948 case OMDParser::ID: {
3949 enterOuterAlt(_localctx, 1);
3950 setState(553);
3951 assignment();
3952 break;
3953 }
3954
3955 case OMDParser::MEMBERS: {
3956 enterOuterAlt(_localctx, 2);
3957 setState(554);
3958 match(OMDParser::MEMBERS);
3959 setState(555);
3960 match(OMDParser::LPAREN);
3961 setState(556);
3962 inttuple();
3963 setState(557);
3964 match(OMDParser::RPAREN);
3965 setState(558);
3966 match(OMDParser::SEMICOLON);
3967 break;
3968 }
3969
3970 default:
3971 throw NoViableAltException(this);
3972 }
3973
3974 }
3975 catch (RecognitionException &e) {
3976 _errHandler->reportError(this, e);
3977 _localctx->exception = std::current_exception();
3978 _errHandler->recover(this, _localctx->exception);
3979 }
3980
3981 return _localctx;
3982}
3983
3984//----------------- NodesblockContext ------------------------------------------------------------------
3985
3986OMDParser::NodesblockContext::NodesblockContext(ParserRuleContext *parent, size_t invokingState)
3987 : ParserRuleContext(parent, invokingState) {
3988}
3989
3990tree::TerminalNode* OMDParser::NodesblockContext::NODES() {
3991 return getToken(OMDParser::NODES, 0);
3992}
3993
3994tree::TerminalNode* OMDParser::NodesblockContext::LCURLY() {
3995 return getToken(OMDParser::LCURLY, 0);
3996}
3997
3998tree::TerminalNode* OMDParser::NodesblockContext::RCURLY() {
3999 return getToken(OMDParser::RCURLY, 0);
4000}
4001
4002tree::TerminalNode* OMDParser::NodesblockContext::LBRACKET() {
4003 return getToken(OMDParser::LBRACKET, 0);
4004}
4005
4006OMDParser::IntConstContext* OMDParser::NodesblockContext::intConst() {
4007 return getRuleContext<OMDParser::IntConstContext>(0);
4008}
4009
4010tree::TerminalNode* OMDParser::NodesblockContext::RBRACKET() {
4011 return getToken(OMDParser::RBRACKET, 0);
4012}
4013
4014std::vector<OMDParser::NodesstatementContext *> OMDParser::NodesblockContext::nodesstatement() {
4015 return getRuleContexts<OMDParser::NodesstatementContext>();
4016}
4017
4018OMDParser::NodesstatementContext* OMDParser::NodesblockContext::nodesstatement(size_t i) {
4019 return getRuleContext<OMDParser::NodesstatementContext>(i);
4020}
4021
4022
4023size_t OMDParser::NodesblockContext::getRuleIndex() const {
4024 return OMDParser::RuleNodesblock;
4025}
4026
4027void OMDParser::NodesblockContext::enterRule(tree::ParseTreeListener *listener) {
4028 auto parserListener = dynamic_cast<OMDListener *>(listener);
4029 if (parserListener != nullptr)
4030 parserListener->enterNodesblock(this);
4031}
4032
4033void OMDParser::NodesblockContext::exitRule(tree::ParseTreeListener *listener) {
4034 auto parserListener = dynamic_cast<OMDListener *>(listener);
4035 if (parserListener != nullptr)
4036 parserListener->exitNodesblock(this);
4037}
4038
4039
4040std::any OMDParser::NodesblockContext::accept(tree::ParseTreeVisitor *visitor) {
4041 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4042 return parserVisitor->visitNodesblock(this);
4043 else
4044 return visitor->visitChildren(this);
4045}
4046
4047OMDParser::NodesblockContext* OMDParser::nodesblock() {
4048 NodesblockContext *_localctx = _tracker.createInstance<NodesblockContext>(_ctx, getState());
4049 enterRule(_localctx, 56, OMDParser::RuleNodesblock);
4050 size_t _la = 0;
4051
4052#if __cplusplus > 201703L
4053 auto onExit = finally([=, this] {
4054#else
4055 auto onExit = finally([=] {
4056#endif
4057 exitRule();
4058 });
4059 try {
4060 enterOuterAlt(_localctx, 1);
4061 setState(562);
4062 match(OMDParser::NODES);
4063 setState(567);
4064 _errHandler->sync(this);
4065
4066 _la = _input->LA(1);
4067 if (_la == OMDParser::LBRACKET) {
4068 setState(563);
4069 match(OMDParser::LBRACKET);
4070 setState(564);
4071 intConst();
4072 setState(565);
4073 match(OMDParser::RBRACKET);
4074 }
4075 setState(569);
4076 match(OMDParser::LCURLY);
4077 setState(573);
4078 _errHandler->sync(this);
4079 _la = _input->LA(1);
4080 while (_la == OMDParser::MEMBERS
4081
4082 || _la == OMDParser::ID) {
4083 setState(570);
4084 nodesstatement();
4085 setState(575);
4086 _errHandler->sync(this);
4087 _la = _input->LA(1);
4088 }
4089 setState(576);
4090 match(OMDParser::RCURLY);
4091
4092 }
4093 catch (RecognitionException &e) {
4094 _errHandler->reportError(this, e);
4095 _localctx->exception = std::current_exception();
4096 _errHandler->recover(this, _localctx->exception);
4097 }
4098
4099 return _localctx;
4100}
4101
4102//----------------- NodesstatementContext ------------------------------------------------------------------
4103
4104OMDParser::NodesstatementContext::NodesstatementContext(ParserRuleContext *parent, size_t invokingState)
4105 : ParserRuleContext(parent, invokingState) {
4106}
4107
4108OMDParser::AssignmentContext* OMDParser::NodesstatementContext::assignment() {
4109 return getRuleContext<OMDParser::AssignmentContext>(0);
4110}
4111
4112tree::TerminalNode* OMDParser::NodesstatementContext::MEMBERS() {
4113 return getToken(OMDParser::MEMBERS, 0);
4114}
4115
4116tree::TerminalNode* OMDParser::NodesstatementContext::LPAREN() {
4117 return getToken(OMDParser::LPAREN, 0);
4118}
4119
4120OMDParser::InttupleContext* OMDParser::NodesstatementContext::inttuple() {
4121 return getRuleContext<OMDParser::InttupleContext>(0);
4122}
4123
4124tree::TerminalNode* OMDParser::NodesstatementContext::RPAREN() {
4125 return getToken(OMDParser::RPAREN, 0);
4126}
4127
4128tree::TerminalNode* OMDParser::NodesstatementContext::SEMICOLON() {
4129 return getToken(OMDParser::SEMICOLON, 0);
4130}
4131
4132
4133size_t OMDParser::NodesstatementContext::getRuleIndex() const {
4134 return OMDParser::RuleNodesstatement;
4135}
4136
4137void OMDParser::NodesstatementContext::enterRule(tree::ParseTreeListener *listener) {
4138 auto parserListener = dynamic_cast<OMDListener *>(listener);
4139 if (parserListener != nullptr)
4140 parserListener->enterNodesstatement(this);
4141}
4142
4143void OMDParser::NodesstatementContext::exitRule(tree::ParseTreeListener *listener) {
4144 auto parserListener = dynamic_cast<OMDListener *>(listener);
4145 if (parserListener != nullptr)
4146 parserListener->exitNodesstatement(this);
4147}
4148
4149
4150std::any OMDParser::NodesstatementContext::accept(tree::ParseTreeVisitor *visitor) {
4151 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4152 return parserVisitor->visitNodesstatement(this);
4153 else
4154 return visitor->visitChildren(this);
4155}
4156
4157OMDParser::NodesstatementContext* OMDParser::nodesstatement() {
4158 NodesstatementContext *_localctx = _tracker.createInstance<NodesstatementContext>(_ctx, getState());
4159 enterRule(_localctx, 58, OMDParser::RuleNodesstatement);
4160
4161#if __cplusplus > 201703L
4162 auto onExit = finally([=, this] {
4163#else
4164 auto onExit = finally([=] {
4165#endif
4166 exitRule();
4167 });
4168 try {
4169 setState(585);
4170 _errHandler->sync(this);
4171 switch (_input->LA(1)) {
4172 case OMDParser::ID: {
4173 enterOuterAlt(_localctx, 1);
4174 setState(578);
4175 assignment();
4176 break;
4177 }
4178
4179 case OMDParser::MEMBERS: {
4180 enterOuterAlt(_localctx, 2);
4181 setState(579);
4182 match(OMDParser::MEMBERS);
4183 setState(580);
4184 match(OMDParser::LPAREN);
4185 setState(581);
4186 inttuple();
4187 setState(582);
4188 match(OMDParser::RPAREN);
4189 setState(583);
4190 match(OMDParser::SEMICOLON);
4191 break;
4192 }
4193
4194 default:
4195 throw NoViableAltException(this);
4196 }
4197
4198 }
4199 catch (RecognitionException &e) {
4200 _errHandler->reportError(this, e);
4201 _localctx->exception = std::current_exception();
4202 _errHandler->recover(this, _localctx->exception);
4203 }
4204
4205 return _localctx;
4206}
4207
4208//----------------- FragmentblockContext ------------------------------------------------------------------
4209
4210OMDParser::FragmentblockContext::FragmentblockContext(ParserRuleContext *parent, size_t invokingState)
4211 : ParserRuleContext(parent, invokingState) {
4212}
4213
4214tree::TerminalNode* OMDParser::FragmentblockContext::FRAGMENT() {
4215 return getToken(OMDParser::FRAGMENT, 0);
4216}
4217
4218tree::TerminalNode* OMDParser::FragmentblockContext::LCURLY() {
4219 return getToken(OMDParser::LCURLY, 0);
4220}
4221
4222tree::TerminalNode* OMDParser::FragmentblockContext::RCURLY() {
4223 return getToken(OMDParser::RCURLY, 0);
4224}
4225
4226std::vector<OMDParser::FragmentstatementContext *> OMDParser::FragmentblockContext::fragmentstatement() {
4227 return getRuleContexts<OMDParser::FragmentstatementContext>();
4228}
4229
4230OMDParser::FragmentstatementContext* OMDParser::FragmentblockContext::fragmentstatement(size_t i) {
4231 return getRuleContext<OMDParser::FragmentstatementContext>(i);
4232}
4233
4234
4235size_t OMDParser::FragmentblockContext::getRuleIndex() const {
4236 return OMDParser::RuleFragmentblock;
4237}
4238
4239void OMDParser::FragmentblockContext::enterRule(tree::ParseTreeListener *listener) {
4240 auto parserListener = dynamic_cast<OMDListener *>(listener);
4241 if (parserListener != nullptr)
4242 parserListener->enterFragmentblock(this);
4243}
4244
4245void OMDParser::FragmentblockContext::exitRule(tree::ParseTreeListener *listener) {
4246 auto parserListener = dynamic_cast<OMDListener *>(listener);
4247 if (parserListener != nullptr)
4248 parserListener->exitFragmentblock(this);
4249}
4250
4251
4252std::any OMDParser::FragmentblockContext::accept(tree::ParseTreeVisitor *visitor) {
4253 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4254 return parserVisitor->visitFragmentblock(this);
4255 else
4256 return visitor->visitChildren(this);
4257}
4258
4259OMDParser::FragmentblockContext* OMDParser::fragmentblock() {
4260 FragmentblockContext *_localctx = _tracker.createInstance<FragmentblockContext>(_ctx, getState());
4261 enterRule(_localctx, 60, OMDParser::RuleFragmentblock);
4262 size_t _la = 0;
4263
4264#if __cplusplus > 201703L
4265 auto onExit = finally([=, this] {
4266#else
4267 auto onExit = finally([=] {
4268#endif
4269 exitRule();
4270 });
4271 try {
4272 enterOuterAlt(_localctx, 1);
4273 setState(587);
4274 match(OMDParser::FRAGMENT);
4275 setState(588);
4276 match(OMDParser::LCURLY);
4277 setState(592);
4278 _errHandler->sync(this);
4279 _la = _input->LA(1);
4280 while (((((_la - 7) & ~ 0x3fULL) == 0) &&
4281 ((1ULL << (_la - 7)) & 288230925907525887) != 0)) {
4282 setState(589);
4283 fragmentstatement();
4284 setState(594);
4285 _errHandler->sync(this);
4286 _la = _input->LA(1);
4287 }
4288 setState(595);
4289 match(OMDParser::RCURLY);
4290
4291 }
4292 catch (RecognitionException &e) {
4293 _errHandler->reportError(this, e);
4294 _localctx->exception = std::current_exception();
4295 _errHandler->recover(this, _localctx->exception);
4296 }
4297
4298 return _localctx;
4299}
4300
4301//----------------- FragmentstatementContext ------------------------------------------------------------------
4302
4303OMDParser::FragmentstatementContext::FragmentstatementContext(ParserRuleContext *parent, size_t invokingState)
4304 : ParserRuleContext(parent, invokingState) {
4305}
4306
4307OMDParser::AssignmentContext* OMDParser::FragmentstatementContext::assignment() {
4308 return getRuleContext<OMDParser::AssignmentContext>(0);
4309}
4310
4311OMDParser::AtomblockContext* OMDParser::FragmentstatementContext::atomblock() {
4312 return getRuleContext<OMDParser::AtomblockContext>(0);
4313}
4314
4315OMDParser::BondblockContext* OMDParser::FragmentstatementContext::bondblock() {
4316 return getRuleContext<OMDParser::BondblockContext>(0);
4317}
4318
4319OMDParser::BendblockContext* OMDParser::FragmentstatementContext::bendblock() {
4320 return getRuleContext<OMDParser::BendblockContext>(0);
4321}
4322
4323OMDParser::TorsionblockContext* OMDParser::FragmentstatementContext::torsionblock() {
4324 return getRuleContext<OMDParser::TorsionblockContext>(0);
4325}
4326
4327OMDParser::InversionblockContext* OMDParser::FragmentstatementContext::inversionblock() {
4328 return getRuleContext<OMDParser::InversionblockContext>(0);
4329}
4330
4331OMDParser::RigidbodyblockContext* OMDParser::FragmentstatementContext::rigidbodyblock() {
4332 return getRuleContext<OMDParser::RigidbodyblockContext>(0);
4333}
4334
4335OMDParser::CutoffgroupblockContext* OMDParser::FragmentstatementContext::cutoffgroupblock() {
4336 return getRuleContext<OMDParser::CutoffgroupblockContext>(0);
4337}
4338
4339OMDParser::ConstraintblockContext* OMDParser::FragmentstatementContext::constraintblock() {
4340 return getRuleContext<OMDParser::ConstraintblockContext>(0);
4341}
4342
4343OMDParser::NodesblockContext* OMDParser::FragmentstatementContext::nodesblock() {
4344 return getRuleContext<OMDParser::NodesblockContext>(0);
4345}
4346
4347
4348size_t OMDParser::FragmentstatementContext::getRuleIndex() const {
4349 return OMDParser::RuleFragmentstatement;
4350}
4351
4352void OMDParser::FragmentstatementContext::enterRule(tree::ParseTreeListener *listener) {
4353 auto parserListener = dynamic_cast<OMDListener *>(listener);
4354 if (parserListener != nullptr)
4355 parserListener->enterFragmentstatement(this);
4356}
4357
4358void OMDParser::FragmentstatementContext::exitRule(tree::ParseTreeListener *listener) {
4359 auto parserListener = dynamic_cast<OMDListener *>(listener);
4360 if (parserListener != nullptr)
4361 parserListener->exitFragmentstatement(this);
4362}
4363
4364
4365std::any OMDParser::FragmentstatementContext::accept(tree::ParseTreeVisitor *visitor) {
4366 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4367 return parserVisitor->visitFragmentstatement(this);
4368 else
4369 return visitor->visitChildren(this);
4370}
4371
4372OMDParser::FragmentstatementContext* OMDParser::fragmentstatement() {
4373 FragmentstatementContext *_localctx = _tracker.createInstance<FragmentstatementContext>(_ctx, getState());
4374 enterRule(_localctx, 62, OMDParser::RuleFragmentstatement);
4375
4376#if __cplusplus > 201703L
4377 auto onExit = finally([=, this] {
4378#else
4379 auto onExit = finally([=] {
4380#endif
4381 exitRule();
4382 });
4383 try {
4384 setState(607);
4385 _errHandler->sync(this);
4386 switch (_input->LA(1)) {
4387 case OMDParser::ID: {
4388 enterOuterAlt(_localctx, 1);
4389 setState(597);
4390 assignment();
4391 break;
4392 }
4393
4394 case OMDParser::ATOM: {
4395 enterOuterAlt(_localctx, 2);
4396 setState(598);
4397 atomblock();
4398 break;
4399 }
4400
4401 case OMDParser::BOND: {
4402 enterOuterAlt(_localctx, 3);
4403 setState(599);
4404 bondblock();
4405 break;
4406 }
4407
4408 case OMDParser::BEND: {
4409 enterOuterAlt(_localctx, 4);
4410 setState(600);
4411 bendblock();
4412 break;
4413 }
4414
4415 case OMDParser::TORSION: {
4416 enterOuterAlt(_localctx, 5);
4417 setState(601);
4418 torsionblock();
4419 break;
4420 }
4421
4422 case OMDParser::INVERSION: {
4423 enterOuterAlt(_localctx, 6);
4424 setState(602);
4425 inversionblock();
4426 break;
4427 }
4428
4429 case OMDParser::RIGIDBODY: {
4430 enterOuterAlt(_localctx, 7);
4431 setState(603);
4432 rigidbodyblock();
4433 break;
4434 }
4435
4436 case OMDParser::CUTOFFGROUP: {
4437 enterOuterAlt(_localctx, 8);
4438 setState(604);
4439 cutoffgroupblock();
4440 break;
4441 }
4442
4443 case OMDParser::CONSTRAINT: {
4444 enterOuterAlt(_localctx, 9);
4445 setState(605);
4446 constraintblock();
4447 break;
4448 }
4449
4450 case OMDParser::NODES: {
4451 enterOuterAlt(_localctx, 10);
4452 setState(606);
4453 nodesblock();
4454 break;
4455 }
4456
4457 default:
4458 throw NoViableAltException(this);
4459 }
4460
4461 }
4462 catch (RecognitionException &e) {
4463 _errHandler->reportError(this, e);
4464 _localctx->exception = std::current_exception();
4465 _errHandler->recover(this, _localctx->exception);
4466 }
4467
4468 return _localctx;
4469}
4470
4471//----------------- ConstraintblockContext ------------------------------------------------------------------
4472
4473OMDParser::ConstraintblockContext::ConstraintblockContext(ParserRuleContext *parent, size_t invokingState)
4474 : ParserRuleContext(parent, invokingState) {
4475}
4476
4477tree::TerminalNode* OMDParser::ConstraintblockContext::CONSTRAINT() {
4478 return getToken(OMDParser::CONSTRAINT, 0);
4479}
4480
4481tree::TerminalNode* OMDParser::ConstraintblockContext::LCURLY() {
4482 return getToken(OMDParser::LCURLY, 0);
4483}
4484
4485tree::TerminalNode* OMDParser::ConstraintblockContext::RCURLY() {
4486 return getToken(OMDParser::RCURLY, 0);
4487}
4488
4489tree::TerminalNode* OMDParser::ConstraintblockContext::LBRACKET() {
4490 return getToken(OMDParser::LBRACKET, 0);
4491}
4492
4493OMDParser::IntConstContext* OMDParser::ConstraintblockContext::intConst() {
4494 return getRuleContext<OMDParser::IntConstContext>(0);
4495}
4496
4497tree::TerminalNode* OMDParser::ConstraintblockContext::RBRACKET() {
4498 return getToken(OMDParser::RBRACKET, 0);
4499}
4500
4501std::vector<OMDParser::ConstraintstatementContext *> OMDParser::ConstraintblockContext::constraintstatement() {
4502 return getRuleContexts<OMDParser::ConstraintstatementContext>();
4503}
4504
4505OMDParser::ConstraintstatementContext* OMDParser::ConstraintblockContext::constraintstatement(size_t i) {
4506 return getRuleContext<OMDParser::ConstraintstatementContext>(i);
4507}
4508
4509
4510size_t OMDParser::ConstraintblockContext::getRuleIndex() const {
4511 return OMDParser::RuleConstraintblock;
4512}
4513
4514void OMDParser::ConstraintblockContext::enterRule(tree::ParseTreeListener *listener) {
4515 auto parserListener = dynamic_cast<OMDListener *>(listener);
4516 if (parserListener != nullptr)
4517 parserListener->enterConstraintblock(this);
4518}
4519
4520void OMDParser::ConstraintblockContext::exitRule(tree::ParseTreeListener *listener) {
4521 auto parserListener = dynamic_cast<OMDListener *>(listener);
4522 if (parserListener != nullptr)
4523 parserListener->exitConstraintblock(this);
4524}
4525
4526
4527std::any OMDParser::ConstraintblockContext::accept(tree::ParseTreeVisitor *visitor) {
4528 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4529 return parserVisitor->visitConstraintblock(this);
4530 else
4531 return visitor->visitChildren(this);
4532}
4533
4534OMDParser::ConstraintblockContext* OMDParser::constraintblock() {
4535 ConstraintblockContext *_localctx = _tracker.createInstance<ConstraintblockContext>(_ctx, getState());
4536 enterRule(_localctx, 64, OMDParser::RuleConstraintblock);
4537 size_t _la = 0;
4538
4539#if __cplusplus > 201703L
4540 auto onExit = finally([=, this] {
4541#else
4542 auto onExit = finally([=] {
4543#endif
4544 exitRule();
4545 });
4546 try {
4547 enterOuterAlt(_localctx, 1);
4548 setState(609);
4549 match(OMDParser::CONSTRAINT);
4550 setState(614);
4551 _errHandler->sync(this);
4552
4553 _la = _input->LA(1);
4554 if (_la == OMDParser::LBRACKET) {
4555 setState(610);
4556 match(OMDParser::LBRACKET);
4557 setState(611);
4558 intConst();
4559 setState(612);
4560 match(OMDParser::RBRACKET);
4561 }
4562 setState(616);
4563 match(OMDParser::LCURLY);
4564 setState(620);
4565 _errHandler->sync(this);
4566 _la = _input->LA(1);
4567 while (_la == OMDParser::MEMBERS
4568
4569 || _la == OMDParser::ID) {
4570 setState(617);
4571 constraintstatement();
4572 setState(622);
4573 _errHandler->sync(this);
4574 _la = _input->LA(1);
4575 }
4576 setState(623);
4577 match(OMDParser::RCURLY);
4578
4579 }
4580 catch (RecognitionException &e) {
4581 _errHandler->reportError(this, e);
4582 _localctx->exception = std::current_exception();
4583 _errHandler->recover(this, _localctx->exception);
4584 }
4585
4586 return _localctx;
4587}
4588
4589//----------------- ConstraintstatementContext ------------------------------------------------------------------
4590
4591OMDParser::ConstraintstatementContext::ConstraintstatementContext(ParserRuleContext *parent, size_t invokingState)
4592 : ParserRuleContext(parent, invokingState) {
4593}
4594
4595OMDParser::AssignmentContext* OMDParser::ConstraintstatementContext::assignment() {
4596 return getRuleContext<OMDParser::AssignmentContext>(0);
4597}
4598
4599tree::TerminalNode* OMDParser::ConstraintstatementContext::MEMBERS() {
4600 return getToken(OMDParser::MEMBERS, 0);
4601}
4602
4603tree::TerminalNode* OMDParser::ConstraintstatementContext::LPAREN() {
4604 return getToken(OMDParser::LPAREN, 0);
4605}
4606
4607OMDParser::InttupleContext* OMDParser::ConstraintstatementContext::inttuple() {
4608 return getRuleContext<OMDParser::InttupleContext>(0);
4609}
4610
4611tree::TerminalNode* OMDParser::ConstraintstatementContext::RPAREN() {
4612 return getToken(OMDParser::RPAREN, 0);
4613}
4614
4615tree::TerminalNode* OMDParser::ConstraintstatementContext::SEMICOLON() {
4616 return getToken(OMDParser::SEMICOLON, 0);
4617}
4618
4619
4620size_t OMDParser::ConstraintstatementContext::getRuleIndex() const {
4621 return OMDParser::RuleConstraintstatement;
4622}
4623
4624void OMDParser::ConstraintstatementContext::enterRule(tree::ParseTreeListener *listener) {
4625 auto parserListener = dynamic_cast<OMDListener *>(listener);
4626 if (parserListener != nullptr)
4627 parserListener->enterConstraintstatement(this);
4628}
4629
4630void OMDParser::ConstraintstatementContext::exitRule(tree::ParseTreeListener *listener) {
4631 auto parserListener = dynamic_cast<OMDListener *>(listener);
4632 if (parserListener != nullptr)
4633 parserListener->exitConstraintstatement(this);
4634}
4635
4636
4637std::any OMDParser::ConstraintstatementContext::accept(tree::ParseTreeVisitor *visitor) {
4638 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4639 return parserVisitor->visitConstraintstatement(this);
4640 else
4641 return visitor->visitChildren(this);
4642}
4643
4644OMDParser::ConstraintstatementContext* OMDParser::constraintstatement() {
4645 ConstraintstatementContext *_localctx = _tracker.createInstance<ConstraintstatementContext>(_ctx, getState());
4646 enterRule(_localctx, 66, OMDParser::RuleConstraintstatement);
4647
4648#if __cplusplus > 201703L
4649 auto onExit = finally([=, this] {
4650#else
4651 auto onExit = finally([=] {
4652#endif
4653 exitRule();
4654 });
4655 try {
4656 setState(632);
4657 _errHandler->sync(this);
4658 switch (_input->LA(1)) {
4659 case OMDParser::ID: {
4660 enterOuterAlt(_localctx, 1);
4661 setState(625);
4662 assignment();
4663 break;
4664 }
4665
4666 case OMDParser::MEMBERS: {
4667 enterOuterAlt(_localctx, 2);
4668 setState(626);
4669 match(OMDParser::MEMBERS);
4670 setState(627);
4671 match(OMDParser::LPAREN);
4672 setState(628);
4673 inttuple();
4674 setState(629);
4675 match(OMDParser::RPAREN);
4676 setState(630);
4677 match(OMDParser::SEMICOLON);
4678 break;
4679 }
4680
4681 default:
4682 throw NoViableAltException(this);
4683 }
4684
4685 }
4686 catch (RecognitionException &e) {
4687 _errHandler->reportError(this, e);
4688 _localctx->exception = std::current_exception();
4689 _errHandler->recover(this, _localctx->exception);
4690 }
4691
4692 return _localctx;
4693}
4694
4695//----------------- SequencestringContext ------------------------------------------------------------------
4696
4697OMDParser::SequencestringContext::SequencestringContext(ParserRuleContext *parent, size_t invokingState)
4698 : ParserRuleContext(parent, invokingState) {
4699}
4700
4701tree::TerminalNode* OMDParser::SequencestringContext::SEQUENCE() {
4702 return getToken(OMDParser::SEQUENCE, 0);
4703}
4704
4705tree::TerminalNode* OMDParser::SequencestringContext::ASSIGNEQUAL() {
4706 return getToken(OMDParser::ASSIGNEQUAL, 0);
4707}
4708
4709OMDParser::ConstantContext* OMDParser::SequencestringContext::constant() {
4710 return getRuleContext<OMDParser::ConstantContext>(0);
4711}
4712
4713tree::TerminalNode* OMDParser::SequencestringContext::SEMICOLON() {
4714 return getToken(OMDParser::SEMICOLON, 0);
4715}
4716
4717
4718size_t OMDParser::SequencestringContext::getRuleIndex() const {
4719 return OMDParser::RuleSequencestring;
4720}
4721
4722void OMDParser::SequencestringContext::enterRule(tree::ParseTreeListener *listener) {
4723 auto parserListener = dynamic_cast<OMDListener *>(listener);
4724 if (parserListener != nullptr)
4725 parserListener->enterSequencestring(this);
4726}
4727
4728void OMDParser::SequencestringContext::exitRule(tree::ParseTreeListener *listener) {
4729 auto parserListener = dynamic_cast<OMDListener *>(listener);
4730 if (parserListener != nullptr)
4731 parserListener->exitSequencestring(this);
4732}
4733
4734
4735std::any OMDParser::SequencestringContext::accept(tree::ParseTreeVisitor *visitor) {
4736 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4737 return parserVisitor->visitSequencestring(this);
4738 else
4739 return visitor->visitChildren(this);
4740}
4741
4742OMDParser::SequencestringContext* OMDParser::sequencestring() {
4743 SequencestringContext *_localctx = _tracker.createInstance<SequencestringContext>(_ctx, getState());
4744 enterRule(_localctx, 68, OMDParser::RuleSequencestring);
4745
4746#if __cplusplus > 201703L
4747 auto onExit = finally([=, this] {
4748#else
4749 auto onExit = finally([=] {
4750#endif
4751 exitRule();
4752 });
4753 try {
4754 enterOuterAlt(_localctx, 1);
4755 setState(634);
4756 match(OMDParser::SEQUENCE);
4757 setState(635);
4758 match(OMDParser::ASSIGNEQUAL);
4759 setState(636);
4760 constant();
4761 setState(637);
4762 match(OMDParser::SEMICOLON);
4763
4764 }
4765 catch (RecognitionException &e) {
4766 _errHandler->reportError(this, e);
4767 _localctx->exception = std::current_exception();
4768 _errHandler->recover(this, _localctx->exception);
4769 }
4770
4771 return _localctx;
4772}
4773
4774//----------------- DoubleNumberTupleContext ------------------------------------------------------------------
4775
4776OMDParser::DoubleNumberTupleContext::DoubleNumberTupleContext(ParserRuleContext *parent, size_t invokingState)
4777 : ParserRuleContext(parent, invokingState) {
4778}
4779
4780std::vector<OMDParser::DoubleNumberContext *> OMDParser::DoubleNumberTupleContext::doubleNumber() {
4781 return getRuleContexts<OMDParser::DoubleNumberContext>();
4782}
4783
4784OMDParser::DoubleNumberContext* OMDParser::DoubleNumberTupleContext::doubleNumber(size_t i) {
4785 return getRuleContext<OMDParser::DoubleNumberContext>(i);
4786}
4787
4788std::vector<tree::TerminalNode *> OMDParser::DoubleNumberTupleContext::COMMA() {
4789 return getTokens(OMDParser::COMMA);
4790}
4791
4792tree::TerminalNode* OMDParser::DoubleNumberTupleContext::COMMA(size_t i) {
4793 return getToken(OMDParser::COMMA, i);
4794}
4795
4796
4797size_t OMDParser::DoubleNumberTupleContext::getRuleIndex() const {
4798 return OMDParser::RuleDoubleNumberTuple;
4799}
4800
4801void OMDParser::DoubleNumberTupleContext::enterRule(tree::ParseTreeListener *listener) {
4802 auto parserListener = dynamic_cast<OMDListener *>(listener);
4803 if (parserListener != nullptr)
4804 parserListener->enterDoubleNumberTuple(this);
4805}
4806
4807void OMDParser::DoubleNumberTupleContext::exitRule(tree::ParseTreeListener *listener) {
4808 auto parserListener = dynamic_cast<OMDListener *>(listener);
4809 if (parserListener != nullptr)
4810 parserListener->exitDoubleNumberTuple(this);
4811}
4812
4813
4814std::any OMDParser::DoubleNumberTupleContext::accept(tree::ParseTreeVisitor *visitor) {
4815 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4816 return parserVisitor->visitDoubleNumberTuple(this);
4817 else
4818 return visitor->visitChildren(this);
4819}
4820
4821OMDParser::DoubleNumberTupleContext* OMDParser::doubleNumberTuple() {
4822 DoubleNumberTupleContext *_localctx = _tracker.createInstance<DoubleNumberTupleContext>(_ctx, getState());
4823 enterRule(_localctx, 70, OMDParser::RuleDoubleNumberTuple);
4824 size_t _la = 0;
4825
4826#if __cplusplus > 201703L
4827 auto onExit = finally([=, this] {
4828#else
4829 auto onExit = finally([=] {
4830#endif
4831 exitRule();
4832 });
4833 try {
4834 enterOuterAlt(_localctx, 1);
4835 setState(639);
4836 doubleNumber();
4837 setState(644);
4838 _errHandler->sync(this);
4839 _la = _input->LA(1);
4840 while (_la == OMDParser::COMMA) {
4841 setState(640);
4842 match(OMDParser::COMMA);
4843 setState(641);
4844 doubleNumber();
4845 setState(646);
4846 _errHandler->sync(this);
4847 _la = _input->LA(1);
4848 }
4849
4850 }
4851 catch (RecognitionException &e) {
4852 _errHandler->reportError(this, e);
4853 _localctx->exception = std::current_exception();
4854 _errHandler->recover(this, _localctx->exception);
4855 }
4856
4857 return _localctx;
4858}
4859
4860//----------------- InttupleContext ------------------------------------------------------------------
4861
4862OMDParser::InttupleContext::InttupleContext(ParserRuleContext *parent, size_t invokingState)
4863 : ParserRuleContext(parent, invokingState) {
4864}
4865
4866std::vector<OMDParser::IntConstContext *> OMDParser::InttupleContext::intConst() {
4867 return getRuleContexts<OMDParser::IntConstContext>();
4868}
4869
4870OMDParser::IntConstContext* OMDParser::InttupleContext::intConst(size_t i) {
4871 return getRuleContext<OMDParser::IntConstContext>(i);
4872}
4873
4874std::vector<tree::TerminalNode *> OMDParser::InttupleContext::COMMA() {
4875 return getTokens(OMDParser::COMMA);
4876}
4877
4878tree::TerminalNode* OMDParser::InttupleContext::COMMA(size_t i) {
4879 return getToken(OMDParser::COMMA, i);
4880}
4881
4882
4883size_t OMDParser::InttupleContext::getRuleIndex() const {
4884 return OMDParser::RuleInttuple;
4885}
4886
4887void OMDParser::InttupleContext::enterRule(tree::ParseTreeListener *listener) {
4888 auto parserListener = dynamic_cast<OMDListener *>(listener);
4889 if (parserListener != nullptr)
4890 parserListener->enterInttuple(this);
4891}
4892
4893void OMDParser::InttupleContext::exitRule(tree::ParseTreeListener *listener) {
4894 auto parserListener = dynamic_cast<OMDListener *>(listener);
4895 if (parserListener != nullptr)
4896 parserListener->exitInttuple(this);
4897}
4898
4899
4900std::any OMDParser::InttupleContext::accept(tree::ParseTreeVisitor *visitor) {
4901 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4902 return parserVisitor->visitInttuple(this);
4903 else
4904 return visitor->visitChildren(this);
4905}
4906
4907OMDParser::InttupleContext* OMDParser::inttuple() {
4908 InttupleContext *_localctx = _tracker.createInstance<InttupleContext>(_ctx, getState());
4909 enterRule(_localctx, 72, OMDParser::RuleInttuple);
4910 size_t _la = 0;
4911
4912#if __cplusplus > 201703L
4913 auto onExit = finally([=, this] {
4914#else
4915 auto onExit = finally([=] {
4916#endif
4917 exitRule();
4918 });
4919 try {
4920 enterOuterAlt(_localctx, 1);
4921 setState(647);
4922 intConst();
4923 setState(652);
4924 _errHandler->sync(this);
4925 _la = _input->LA(1);
4926 while (_la == OMDParser::COMMA) {
4927 setState(648);
4928 match(OMDParser::COMMA);
4929 setState(649);
4930 intConst();
4931 setState(654);
4932 _errHandler->sync(this);
4933 _la = _input->LA(1);
4934 }
4935
4936 }
4937 catch (RecognitionException &e) {
4938 _errHandler->reportError(this, e);
4939 _localctx->exception = std::current_exception();
4940 _errHandler->recover(this, _localctx->exception);
4941 }
4942
4943 return _localctx;
4944}
4945
4946//----------------- IntConstContext ------------------------------------------------------------------
4947
4948OMDParser::IntConstContext::IntConstContext(ParserRuleContext *parent, size_t invokingState)
4949 : ParserRuleContext(parent, invokingState) {
4950}
4951
4952tree::TerminalNode* OMDParser::IntConstContext::NUM_INT() {
4953 return getToken(OMDParser::NUM_INT, 0);
4954}
4955
4956tree::TerminalNode* OMDParser::IntConstContext::NUM_LONG() {
4957 return getToken(OMDParser::NUM_LONG, 0);
4958}
4959
4960
4961size_t OMDParser::IntConstContext::getRuleIndex() const {
4962 return OMDParser::RuleIntConst;
4963}
4964
4965void OMDParser::IntConstContext::enterRule(tree::ParseTreeListener *listener) {
4966 auto parserListener = dynamic_cast<OMDListener *>(listener);
4967 if (parserListener != nullptr)
4968 parserListener->enterIntConst(this);
4969}
4970
4971void OMDParser::IntConstContext::exitRule(tree::ParseTreeListener *listener) {
4972 auto parserListener = dynamic_cast<OMDListener *>(listener);
4973 if (parserListener != nullptr)
4974 parserListener->exitIntConst(this);
4975}
4976
4977
4978std::any OMDParser::IntConstContext::accept(tree::ParseTreeVisitor *visitor) {
4979 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
4980 return parserVisitor->visitIntConst(this);
4981 else
4982 return visitor->visitChildren(this);
4983}
4984
4985OMDParser::IntConstContext* OMDParser::intConst() {
4986 IntConstContext *_localctx = _tracker.createInstance<IntConstContext>(_ctx, getState());
4987 enterRule(_localctx, 74, OMDParser::RuleIntConst);
4988 size_t _la = 0;
4989
4990#if __cplusplus > 201703L
4991 auto onExit = finally([=, this] {
4992#else
4993 auto onExit = finally([=] {
4994#endif
4995 exitRule();
4996 });
4997 try {
4998 enterOuterAlt(_localctx, 1);
4999 setState(655);
5000 _la = _input->LA(1);
5001 if (!(_la == OMDParser::NUM_LONG
5002
5003 || _la == OMDParser::NUM_INT)) {
5004 _errHandler->recoverInline(this);
5005 }
5006 else {
5007 _errHandler->reportMatch(this);
5008 consume();
5009 }
5010
5011 }
5012 catch (RecognitionException &e) {
5013 _errHandler->reportError(this, e);
5014 _localctx->exception = std::current_exception();
5015 _errHandler->recover(this, _localctx->exception);
5016 }
5017
5018 return _localctx;
5019}
5020
5021//----------------- DoubleNumberContext ------------------------------------------------------------------
5022
5023OMDParser::DoubleNumberContext::DoubleNumberContext(ParserRuleContext *parent, size_t invokingState)
5024 : ParserRuleContext(parent, invokingState) {
5025}
5026
5027OMDParser::IntConstContext* OMDParser::DoubleNumberContext::intConst() {
5028 return getRuleContext<OMDParser::IntConstContext>(0);
5029}
5030
5031OMDParser::FloatConstContext* OMDParser::DoubleNumberContext::floatConst() {
5032 return getRuleContext<OMDParser::FloatConstContext>(0);
5033}
5034
5035
5036size_t OMDParser::DoubleNumberContext::getRuleIndex() const {
5037 return OMDParser::RuleDoubleNumber;
5038}
5039
5040void OMDParser::DoubleNumberContext::enterRule(tree::ParseTreeListener *listener) {
5041 auto parserListener = dynamic_cast<OMDListener *>(listener);
5042 if (parserListener != nullptr)
5043 parserListener->enterDoubleNumber(this);
5044}
5045
5046void OMDParser::DoubleNumberContext::exitRule(tree::ParseTreeListener *listener) {
5047 auto parserListener = dynamic_cast<OMDListener *>(listener);
5048 if (parserListener != nullptr)
5049 parserListener->exitDoubleNumber(this);
5050}
5051
5052
5053std::any OMDParser::DoubleNumberContext::accept(tree::ParseTreeVisitor *visitor) {
5054 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
5055 return parserVisitor->visitDoubleNumber(this);
5056 else
5057 return visitor->visitChildren(this);
5058}
5059
5060OMDParser::DoubleNumberContext* OMDParser::doubleNumber() {
5061 DoubleNumberContext *_localctx = _tracker.createInstance<DoubleNumberContext>(_ctx, getState());
5062 enterRule(_localctx, 76, OMDParser::RuleDoubleNumber);
5063
5064#if __cplusplus > 201703L
5065 auto onExit = finally([=, this] {
5066#else
5067 auto onExit = finally([=] {
5068#endif
5069 exitRule();
5070 });
5071 try {
5072 setState(659);
5073 _errHandler->sync(this);
5074 switch (_input->LA(1)) {
5075 case OMDParser::NUM_LONG:
5076 case OMDParser::NUM_INT: {
5077 enterOuterAlt(_localctx, 1);
5078 setState(657);
5079 intConst();
5080 break;
5081 }
5082
5083 case OMDParser::NUM_FLOAT:
5084 case OMDParser::NUM_DOUBLE: {
5085 enterOuterAlt(_localctx, 2);
5086 setState(658);
5087 floatConst();
5088 break;
5089 }
5090
5091 default:
5092 throw NoViableAltException(this);
5093 }
5094
5095 }
5096 catch (RecognitionException &e) {
5097 _errHandler->reportError(this, e);
5098 _localctx->exception = std::current_exception();
5099 _errHandler->recover(this, _localctx->exception);
5100 }
5101
5102 return _localctx;
5103}
5104
5105//----------------- FloatConstContext ------------------------------------------------------------------
5106
5107OMDParser::FloatConstContext::FloatConstContext(ParserRuleContext *parent, size_t invokingState)
5108 : ParserRuleContext(parent, invokingState) {
5109}
5110
5111tree::TerminalNode* OMDParser::FloatConstContext::NUM_FLOAT() {
5112 return getToken(OMDParser::NUM_FLOAT, 0);
5113}
5114
5115tree::TerminalNode* OMDParser::FloatConstContext::NUM_DOUBLE() {
5116 return getToken(OMDParser::NUM_DOUBLE, 0);
5117}
5118
5119
5120size_t OMDParser::FloatConstContext::getRuleIndex() const {
5121 return OMDParser::RuleFloatConst;
5122}
5123
5124void OMDParser::FloatConstContext::enterRule(tree::ParseTreeListener *listener) {
5125 auto parserListener = dynamic_cast<OMDListener *>(listener);
5126 if (parserListener != nullptr)
5127 parserListener->enterFloatConst(this);
5128}
5129
5130void OMDParser::FloatConstContext::exitRule(tree::ParseTreeListener *listener) {
5131 auto parserListener = dynamic_cast<OMDListener *>(listener);
5132 if (parserListener != nullptr)
5133 parserListener->exitFloatConst(this);
5134}
5135
5136
5137std::any OMDParser::FloatConstContext::accept(tree::ParseTreeVisitor *visitor) {
5138 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
5139 return parserVisitor->visitFloatConst(this);
5140 else
5141 return visitor->visitChildren(this);
5142}
5143
5144OMDParser::FloatConstContext* OMDParser::floatConst() {
5145 FloatConstContext *_localctx = _tracker.createInstance<FloatConstContext>(_ctx, getState());
5146 enterRule(_localctx, 78, OMDParser::RuleFloatConst);
5147 size_t _la = 0;
5148
5149#if __cplusplus > 201703L
5150 auto onExit = finally([=, this] {
5151#else
5152 auto onExit = finally([=] {
5153#endif
5154 exitRule();
5155 });
5156 try {
5157 enterOuterAlt(_localctx, 1);
5158 setState(661);
5159 _la = _input->LA(1);
5160 if (!(_la == OMDParser::NUM_FLOAT
5161
5162 || _la == OMDParser::NUM_DOUBLE)) {
5163 _errHandler->recoverInline(this);
5164 }
5165 else {
5166 _errHandler->reportMatch(this);
5167 consume();
5168 }
5169
5170 }
5171 catch (RecognitionException &e) {
5172 _errHandler->reportError(this, e);
5173 _localctx->exception = std::current_exception();
5174 _errHandler->recover(this, _localctx->exception);
5175 }
5176
5177 return _localctx;
5178}
5179
5180//----------------- VectorConstContext ------------------------------------------------------------------
5181
5182OMDParser::VectorConstContext::VectorConstContext(ParserRuleContext *parent, size_t invokingState)
5183 : ParserRuleContext(parent, invokingState) {
5184}
5185
5186tree::TerminalNode* OMDParser::VectorConstContext::LPAREN() {
5187 return getToken(OMDParser::LPAREN, 0);
5188}
5189
5190OMDParser::DoubleNumberTupleContext* OMDParser::VectorConstContext::doubleNumberTuple() {
5191 return getRuleContext<OMDParser::DoubleNumberTupleContext>(0);
5192}
5193
5194tree::TerminalNode* OMDParser::VectorConstContext::RPAREN() {
5195 return getToken(OMDParser::RPAREN, 0);
5196}
5197
5198
5199size_t OMDParser::VectorConstContext::getRuleIndex() const {
5200 return OMDParser::RuleVectorConst;
5201}
5202
5203void OMDParser::VectorConstContext::enterRule(tree::ParseTreeListener *listener) {
5204 auto parserListener = dynamic_cast<OMDListener *>(listener);
5205 if (parserListener != nullptr)
5206 parserListener->enterVectorConst(this);
5207}
5208
5209void OMDParser::VectorConstContext::exitRule(tree::ParseTreeListener *listener) {
5210 auto parserListener = dynamic_cast<OMDListener *>(listener);
5211 if (parserListener != nullptr)
5212 parserListener->exitVectorConst(this);
5213}
5214
5215
5216std::any OMDParser::VectorConstContext::accept(tree::ParseTreeVisitor *visitor) {
5217 if (auto parserVisitor = dynamic_cast<OMDVisitor*>(visitor))
5218 return parserVisitor->visitVectorConst(this);
5219 else
5220 return visitor->visitChildren(this);
5221}
5222
5223OMDParser::VectorConstContext* OMDParser::vectorConst() {
5224 VectorConstContext *_localctx = _tracker.createInstance<VectorConstContext>(_ctx, getState());
5225 enterRule(_localctx, 80, OMDParser::RuleVectorConst);
5226
5227#if __cplusplus > 201703L
5228 auto onExit = finally([=, this] {
5229#else
5230 auto onExit = finally([=] {
5231#endif
5232 exitRule();
5233 });
5234 try {
5235 enterOuterAlt(_localctx, 1);
5236 setState(663);
5237 match(OMDParser::LPAREN);
5238 setState(664);
5239 doubleNumberTuple();
5240 setState(665);
5241 match(OMDParser::RPAREN);
5242
5243 }
5244 catch (RecognitionException &e) {
5245 _errHandler->reportError(this, e);
5246 _localctx->exception = std::current_exception();
5247 _errHandler->recover(this, _localctx->exception);
5248 }
5249
5250 return _localctx;
5251}
5252
5253void OMDParser::initialize() {
5254#if ANTLR4_USE_THREAD_LOCAL_CACHE
5255 omdParserInitialize();
5256#else
5257 ::antlr4::internal::call_once(omdParserOnceFlag, omdParserInitialize);
5258#endif
5259}