OpenMD 3.2
Molecular Dynamics in the Open
Loading...
Searching...
No Matches
OMDParser.h
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#pragma once
10
11
12#include "antlr4-runtime.h"
13
14
15
16
17class OMDParser : public antlr4::Parser {
18public:
19 enum {
20 TRUE = 1, FALSE = 2, COMPONENT = 3, MOLECULE = 4, ZCONSTRAINT = 5, RESTRAINT = 6,
21 ATOM = 7, BOND = 8, BEND = 9, TORSION = 10, INVERSION = 11, RIGIDBODY = 12,
22 CUTOFFGROUP = 13, CONSTRAINT = 14, DISTANCE = 15, FRAGMENT = 16, SEQUENCE = 17,
23 MEMBERS = 18, CENTER = 19, SATELLITES = 20, POSITION = 21, ORIENTATION = 22,
24 FLUCQ = 23, RNEMD = 24, LIGHT = 25, VELOCITYFIELD = 26, MINIMIZER = 27,
25 FIXED = 28, HARMONIC = 29, CUBIC = 30, QUARTIC = 31, POLYNOMIAL = 32,
26 MORSE = 33, GHOSTBEND = 34, UREYBRADLEY = 35, COSINE = 36, GHOSTTORSION = 37,
27 CHARMM = 38, OPLS = 39, TRAPPE = 40, AMBERIMPROPER = 41, IMPROPERCOSINE = 42,
28 CENTRALATOMHEIGHT = 43, DREIDING = 44, CHARGE = 45, NODES = 46, ASSIGNEQUAL = 47,
29 COLON = 48, COMMA = 49, QUESTIONMARK = 50, SEMICOLON = 51, DOT = 52,
30 LPAREN = 53, RPAREN = 54, LBRACKET = 55, RBRACKET = 56, LCURLY = 57,
31 RCURLY = 58, NUM_LONG = 59, NUM_INT = 60, NUM_FLOAT = 61, NUM_DOUBLE = 62,
32 CharLiteral = 63, StringLiteral = 64, ID = 65, Whitespace = 66, Newline = 67,
33 LineContinuation = 68, Comment = 69, CPPComment = 70, PREPROC_DIRECTIVE = 71
34 };
35
36 enum {
37 RuleOmdfile = 0, RuleStatement = 1, RuleAssignment = 2, RuleConstant = 3,
38 RuleComponentblock = 4, RuleZconstraintblock = 5, RuleRestraintblock = 6,
39 RuleFlucqblock = 7, RuleRnemdblock = 8, RuleLightblock = 9, RuleVelocityfieldblock = 10,
40 RuleMinimizerblock = 11, RuleMoleculeblock = 12, RuleMoleculestatement = 13,
41 RuleAtomblock = 14, RuleAtomstatement = 15, RuleBondblock = 16, RuleBondstatement = 17,
42 RuleBendblock = 18, RuleBendstatement = 19, RuleTorsionblock = 20, RuleTorsionstatement = 21,
43 RuleInversionblock = 22, RuleInversionstatement = 23, RuleRigidbodyblock = 24,
44 RuleRigidbodystatement = 25, RuleCutoffgroupblock = 26, RuleCutoffgroupstatement = 27,
45 RuleNodesblock = 28, RuleNodesstatement = 29, RuleFragmentblock = 30,
46 RuleFragmentstatement = 31, RuleConstraintblock = 32, RuleConstraintstatement = 33,
47 RuleSequencestring = 34, RuleDoubleNumberTuple = 35, RuleInttuple = 36,
48 RuleIntConst = 37, RuleDoubleNumber = 38, RuleFloatConst = 39, RuleVectorConst = 40
49 };
50
51 explicit OMDParser(antlr4::TokenStream *input);
52
53 OMDParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
54
55 ~OMDParser() override;
56
57 std::string getGrammarFileName() const override;
58
59 const antlr4::atn::ATN& getATN() const override;
60
61 const std::vector<std::string>& getRuleNames() const override;
62
63 const antlr4::dfa::Vocabulary& getVocabulary() const override;
64
65 antlr4::atn::SerializedATNView getSerializedATN() const override;
66
67
68 FilenameObserver* observer;
69
70 void setObserver(FilenameObserver* osv) {
71 observer = osv;
72 }
73
74
75 class OmdfileContext;
76 class StatementContext;
77 class AssignmentContext;
78 class ConstantContext;
79 class ComponentblockContext;
80 class ZconstraintblockContext;
81 class RestraintblockContext;
82 class FlucqblockContext;
83 class RnemdblockContext;
84 class LightblockContext;
85 class VelocityfieldblockContext;
86 class MinimizerblockContext;
87 class MoleculeblockContext;
88 class MoleculestatementContext;
89 class AtomblockContext;
90 class AtomstatementContext;
91 class BondblockContext;
92 class BondstatementContext;
93 class BendblockContext;
94 class BendstatementContext;
95 class TorsionblockContext;
96 class TorsionstatementContext;
97 class InversionblockContext;
98 class InversionstatementContext;
99 class RigidbodyblockContext;
100 class RigidbodystatementContext;
101 class CutoffgroupblockContext;
102 class CutoffgroupstatementContext;
103 class NodesblockContext;
104 class NodesstatementContext;
105 class FragmentblockContext;
106 class FragmentstatementContext;
107 class ConstraintblockContext;
108 class ConstraintstatementContext;
109 class SequencestringContext;
110 class DoubleNumberTupleContext;
111 class InttupleContext;
112 class IntConstContext;
113 class DoubleNumberContext;
114 class FloatConstContext;
115 class VectorConstContext;
116
117 class OmdfileContext : public antlr4::ParserRuleContext {
118 public:
119 OmdfileContext(antlr4::ParserRuleContext *parent, size_t invokingState);
120 virtual size_t getRuleIndex() const override;
121 antlr4::tree::TerminalNode *EOF();
122 std::vector<StatementContext *> statement();
123 StatementContext* statement(size_t i);
124
125 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
126 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
127
128 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
129
130 };
131
132 OmdfileContext* omdfile();
133
134 class StatementContext : public antlr4::ParserRuleContext {
135 public:
136 StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
137 virtual size_t getRuleIndex() const override;
138 AssignmentContext *assignment();
139 ComponentblockContext *componentblock();
140 MoleculeblockContext *moleculeblock();
141 FragmentblockContext *fragmentblock();
142 ZconstraintblockContext *zconstraintblock();
143 RestraintblockContext *restraintblock();
144 FlucqblockContext *flucqblock();
145 RnemdblockContext *rnemdblock();
146 LightblockContext *lightblock();
147 VelocityfieldblockContext *velocityfieldblock();
148 MinimizerblockContext *minimizerblock();
149
150 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
151 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
152
153 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
154
155 };
156
157 StatementContext* statement();
158
159 class AssignmentContext : public antlr4::ParserRuleContext {
160 public:
161 AssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
162 virtual size_t getRuleIndex() const override;
163 antlr4::tree::TerminalNode *ID();
164 antlr4::tree::TerminalNode *ASSIGNEQUAL();
165 ConstantContext *constant();
166 antlr4::tree::TerminalNode *SEMICOLON();
167
168 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
169 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
170
171 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
172
173 };
174
175 AssignmentContext* assignment();
176
177 class ConstantContext : public antlr4::ParserRuleContext {
178 public:
179 ConstantContext(antlr4::ParserRuleContext *parent, size_t invokingState);
180 virtual size_t getRuleIndex() const override;
181 IntConstContext *intConst();
182 FloatConstContext *floatConst();
183 VectorConstContext *vectorConst();
184 antlr4::tree::TerminalNode *TRUE();
185 antlr4::tree::TerminalNode *FALSE();
186 antlr4::tree::TerminalNode *ID();
187 antlr4::tree::TerminalNode *StringLiteral();
188
189 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
190 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
191
192 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
193
194 };
195
196 ConstantContext* constant();
197
198 class ComponentblockContext : public antlr4::ParserRuleContext {
199 public:
200 ComponentblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
201 virtual size_t getRuleIndex() const override;
202 antlr4::tree::TerminalNode *COMPONENT();
203 antlr4::tree::TerminalNode *LCURLY();
204 antlr4::tree::TerminalNode *RCURLY();
205 std::vector<AssignmentContext *> assignment();
206 AssignmentContext* assignment(size_t i);
207
208 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
209 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
210
211 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
212
213 };
214
215 ComponentblockContext* componentblock();
216
217 class ZconstraintblockContext : public antlr4::ParserRuleContext {
218 public:
219 ZconstraintblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
220 virtual size_t getRuleIndex() const override;
221 antlr4::tree::TerminalNode *ZCONSTRAINT();
222 antlr4::tree::TerminalNode *LCURLY();
223 antlr4::tree::TerminalNode *RCURLY();
224 std::vector<AssignmentContext *> assignment();
225 AssignmentContext* assignment(size_t i);
226
227 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
228 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
229
230 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
231
232 };
233
234 ZconstraintblockContext* zconstraintblock();
235
236 class RestraintblockContext : public antlr4::ParserRuleContext {
237 public:
238 RestraintblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
239 virtual size_t getRuleIndex() const override;
240 antlr4::tree::TerminalNode *RESTRAINT();
241 antlr4::tree::TerminalNode *LCURLY();
242 antlr4::tree::TerminalNode *RCURLY();
243 std::vector<AssignmentContext *> assignment();
244 AssignmentContext* assignment(size_t i);
245
246 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
247 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
248
249 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
250
251 };
252
253 RestraintblockContext* restraintblock();
254
255 class FlucqblockContext : public antlr4::ParserRuleContext {
256 public:
257 FlucqblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
258 virtual size_t getRuleIndex() const override;
259 antlr4::tree::TerminalNode *FLUCQ();
260 antlr4::tree::TerminalNode *LCURLY();
261 antlr4::tree::TerminalNode *RCURLY();
262 std::vector<AssignmentContext *> assignment();
263 AssignmentContext* assignment(size_t i);
264
265 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
266 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
267
268 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
269
270 };
271
272 FlucqblockContext* flucqblock();
273
274 class RnemdblockContext : public antlr4::ParserRuleContext {
275 public:
276 RnemdblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
277 virtual size_t getRuleIndex() const override;
278 antlr4::tree::TerminalNode *RNEMD();
279 antlr4::tree::TerminalNode *LCURLY();
280 antlr4::tree::TerminalNode *RCURLY();
281 std::vector<AssignmentContext *> assignment();
282 AssignmentContext* assignment(size_t i);
283
284 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
285 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
286
287 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
288
289 };
290
291 RnemdblockContext* rnemdblock();
292
293 class LightblockContext : public antlr4::ParserRuleContext {
294 public:
295 LightblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
296 virtual size_t getRuleIndex() const override;
297 antlr4::tree::TerminalNode *LIGHT();
298 antlr4::tree::TerminalNode *LCURLY();
299 antlr4::tree::TerminalNode *RCURLY();
300 std::vector<AssignmentContext *> assignment();
301 AssignmentContext* assignment(size_t i);
302
303 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
304 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
305
306 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
307
308 };
309
310 LightblockContext* lightblock();
311
312 class VelocityfieldblockContext : public antlr4::ParserRuleContext {
313 public:
314 VelocityfieldblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
315 virtual size_t getRuleIndex() const override;
316 antlr4::tree::TerminalNode *VELOCITYFIELD();
317 antlr4::tree::TerminalNode *LCURLY();
318 antlr4::tree::TerminalNode *RCURLY();
319 std::vector<AssignmentContext *> assignment();
320 AssignmentContext* assignment(size_t i);
321
322 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
323 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
324
325 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
326
327 };
328
329 VelocityfieldblockContext* velocityfieldblock();
330
331 class MinimizerblockContext : public antlr4::ParserRuleContext {
332 public:
333 MinimizerblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
334 virtual size_t getRuleIndex() const override;
335 antlr4::tree::TerminalNode *MINIMIZER();
336 antlr4::tree::TerminalNode *LCURLY();
337 antlr4::tree::TerminalNode *RCURLY();
338 std::vector<AssignmentContext *> assignment();
339 AssignmentContext* assignment(size_t i);
340
341 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
342 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
343
344 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
345
346 };
347
348 MinimizerblockContext* minimizerblock();
349
350 class MoleculeblockContext : public antlr4::ParserRuleContext {
351 public:
352 MoleculeblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
353 virtual size_t getRuleIndex() const override;
354 antlr4::tree::TerminalNode *MOLECULE();
355 antlr4::tree::TerminalNode *LCURLY();
356 antlr4::tree::TerminalNode *RCURLY();
357 std::vector<MoleculestatementContext *> moleculestatement();
358 MoleculestatementContext* moleculestatement(size_t i);
359
360 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
361 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
362
363 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
364
365 };
366
367 MoleculeblockContext* moleculeblock();
368
369 class MoleculestatementContext : public antlr4::ParserRuleContext {
370 public:
371 MoleculestatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
372 virtual size_t getRuleIndex() const override;
373 AssignmentContext *assignment();
374 AtomblockContext *atomblock();
375 BondblockContext *bondblock();
376 BendblockContext *bendblock();
377 TorsionblockContext *torsionblock();
378 InversionblockContext *inversionblock();
379 RigidbodyblockContext *rigidbodyblock();
380 CutoffgroupblockContext *cutoffgroupblock();
381 ConstraintblockContext *constraintblock();
382 SequencestringContext *sequencestring();
383
384 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
385 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
386
387 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
388
389 };
390
391 MoleculestatementContext* moleculestatement();
392
393 class AtomblockContext : public antlr4::ParserRuleContext {
394 public:
395 AtomblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
396 virtual size_t getRuleIndex() const override;
397 antlr4::tree::TerminalNode *ATOM();
398 antlr4::tree::TerminalNode *LBRACKET();
399 IntConstContext *intConst();
400 antlr4::tree::TerminalNode *RBRACKET();
401 antlr4::tree::TerminalNode *LCURLY();
402 antlr4::tree::TerminalNode *RCURLY();
403 std::vector<AtomstatementContext *> atomstatement();
404 AtomstatementContext* atomstatement(size_t i);
405
406 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
407 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
408
409 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
410
411 };
412
413 AtomblockContext* atomblock();
414
415 class AtomstatementContext : public antlr4::ParserRuleContext {
416 public:
417 AtomstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
418 virtual size_t getRuleIndex() const override;
419 AssignmentContext *assignment();
420 antlr4::tree::TerminalNode *POSITION();
421 antlr4::tree::TerminalNode *LPAREN();
422 DoubleNumberTupleContext *doubleNumberTuple();
423 antlr4::tree::TerminalNode *RPAREN();
424 antlr4::tree::TerminalNode *SEMICOLON();
425 antlr4::tree::TerminalNode *ORIENTATION();
426 antlr4::tree::TerminalNode *CHARGE();
427 FloatConstContext *floatConst();
428
429 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
430 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
431
432 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
433
434 };
435
436 AtomstatementContext* atomstatement();
437
438 class BondblockContext : public antlr4::ParserRuleContext {
439 public:
440 BondblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
441 virtual size_t getRuleIndex() const override;
442 antlr4::tree::TerminalNode *BOND();
443 antlr4::tree::TerminalNode *LCURLY();
444 antlr4::tree::TerminalNode *RCURLY();
445 antlr4::tree::TerminalNode *LBRACKET();
446 IntConstContext *intConst();
447 antlr4::tree::TerminalNode *RBRACKET();
448 std::vector<BondstatementContext *> bondstatement();
449 BondstatementContext* bondstatement(size_t i);
450
451 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
452 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
453
454 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
455
456 };
457
458 BondblockContext* bondblock();
459
460 class BondstatementContext : public antlr4::ParserRuleContext {
461 public:
462 BondstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
463 virtual size_t getRuleIndex() const override;
464 AssignmentContext *assignment();
465 antlr4::tree::TerminalNode *MEMBERS();
466 antlr4::tree::TerminalNode *LPAREN();
467 InttupleContext *inttuple();
468 antlr4::tree::TerminalNode *RPAREN();
469 antlr4::tree::TerminalNode *SEMICOLON();
470 antlr4::tree::TerminalNode *FIXED();
471 FloatConstContext *floatConst();
472 antlr4::tree::TerminalNode *HARMONIC();
473 DoubleNumberTupleContext *doubleNumberTuple();
474 antlr4::tree::TerminalNode *CUBIC();
475 antlr4::tree::TerminalNode *QUARTIC();
476 antlr4::tree::TerminalNode *POLYNOMIAL();
477 antlr4::tree::TerminalNode *MORSE();
478
479 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
480 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
481
482 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
483
484 };
485
486 BondstatementContext* bondstatement();
487
488 class BendblockContext : public antlr4::ParserRuleContext {
489 public:
490 BendblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
491 virtual size_t getRuleIndex() const override;
492 antlr4::tree::TerminalNode *BEND();
493 antlr4::tree::TerminalNode *LCURLY();
494 antlr4::tree::TerminalNode *RCURLY();
495 antlr4::tree::TerminalNode *LBRACKET();
496 IntConstContext *intConst();
497 antlr4::tree::TerminalNode *RBRACKET();
498 std::vector<BendstatementContext *> bendstatement();
499 BendstatementContext* bendstatement(size_t i);
500
501 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
502 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
503
504 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
505
506 };
507
508 BendblockContext* bendblock();
509
510 class BendstatementContext : public antlr4::ParserRuleContext {
511 public:
512 BendstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
513 virtual size_t getRuleIndex() const override;
514 AssignmentContext *assignment();
515 antlr4::tree::TerminalNode *MEMBERS();
516 antlr4::tree::TerminalNode *LPAREN();
517 InttupleContext *inttuple();
518 antlr4::tree::TerminalNode *RPAREN();
519 antlr4::tree::TerminalNode *SEMICOLON();
520 antlr4::tree::TerminalNode *HARMONIC();
521 DoubleNumberTupleContext *doubleNumberTuple();
522 antlr4::tree::TerminalNode *GHOSTBEND();
523 antlr4::tree::TerminalNode *UREYBRADLEY();
524 antlr4::tree::TerminalNode *CUBIC();
525 antlr4::tree::TerminalNode *QUARTIC();
526 antlr4::tree::TerminalNode *POLYNOMIAL();
527 antlr4::tree::TerminalNode *COSINE();
528
529 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
530 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
531
532 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
533
534 };
535
536 BendstatementContext* bendstatement();
537
538 class TorsionblockContext : public antlr4::ParserRuleContext {
539 public:
540 TorsionblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
541 virtual size_t getRuleIndex() const override;
542 antlr4::tree::TerminalNode *TORSION();
543 antlr4::tree::TerminalNode *LCURLY();
544 antlr4::tree::TerminalNode *RCURLY();
545 antlr4::tree::TerminalNode *LBRACKET();
546 IntConstContext *intConst();
547 antlr4::tree::TerminalNode *RBRACKET();
548 std::vector<TorsionstatementContext *> torsionstatement();
549 TorsionstatementContext* torsionstatement(size_t i);
550
551 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
552 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
553
554 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
555
556 };
557
558 TorsionblockContext* torsionblock();
559
560 class TorsionstatementContext : public antlr4::ParserRuleContext {
561 public:
562 TorsionstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
563 virtual size_t getRuleIndex() const override;
564 AssignmentContext *assignment();
565 antlr4::tree::TerminalNode *MEMBERS();
566 antlr4::tree::TerminalNode *LPAREN();
567 InttupleContext *inttuple();
568 antlr4::tree::TerminalNode *RPAREN();
569 antlr4::tree::TerminalNode *SEMICOLON();
570 antlr4::tree::TerminalNode *GHOSTTORSION();
571 DoubleNumberTupleContext *doubleNumberTuple();
572 antlr4::tree::TerminalNode *CUBIC();
573 antlr4::tree::TerminalNode *QUARTIC();
574 antlr4::tree::TerminalNode *POLYNOMIAL();
575 antlr4::tree::TerminalNode *CHARMM();
576 antlr4::tree::TerminalNode *OPLS();
577 antlr4::tree::TerminalNode *TRAPPE();
578 antlr4::tree::TerminalNode *HARMONIC();
579
580 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
581 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
582
583 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
584
585 };
586
587 TorsionstatementContext* torsionstatement();
588
589 class InversionblockContext : public antlr4::ParserRuleContext {
590 public:
591 InversionblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
592 virtual size_t getRuleIndex() const override;
593 antlr4::tree::TerminalNode *INVERSION();
594 antlr4::tree::TerminalNode *LCURLY();
595 antlr4::tree::TerminalNode *RCURLY();
596 antlr4::tree::TerminalNode *LBRACKET();
597 IntConstContext *intConst();
598 antlr4::tree::TerminalNode *RBRACKET();
599 std::vector<InversionstatementContext *> inversionstatement();
600 InversionstatementContext* inversionstatement(size_t i);
601
602 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
603 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
604
605 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
606
607 };
608
609 InversionblockContext* inversionblock();
610
611 class InversionstatementContext : public antlr4::ParserRuleContext {
612 public:
613 InversionstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
614 virtual size_t getRuleIndex() const override;
615 AssignmentContext *assignment();
616 antlr4::tree::TerminalNode *CENTER();
617 antlr4::tree::TerminalNode *LPAREN();
618 IntConstContext *intConst();
619 antlr4::tree::TerminalNode *RPAREN();
620 antlr4::tree::TerminalNode *SEMICOLON();
621 antlr4::tree::TerminalNode *SATELLITES();
622 InttupleContext *inttuple();
623 antlr4::tree::TerminalNode *AMBERIMPROPER();
624 DoubleNumberTupleContext *doubleNumberTuple();
625 antlr4::tree::TerminalNode *IMPROPERCOSINE();
626 antlr4::tree::TerminalNode *HARMONIC();
627 antlr4::tree::TerminalNode *CENTRALATOMHEIGHT();
628 antlr4::tree::TerminalNode *DREIDING();
629
630 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
631 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
632
633 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
634
635 };
636
637 InversionstatementContext* inversionstatement();
638
639 class RigidbodyblockContext : public antlr4::ParserRuleContext {
640 public:
641 RigidbodyblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
642 virtual size_t getRuleIndex() const override;
643 antlr4::tree::TerminalNode *RIGIDBODY();
644 antlr4::tree::TerminalNode *LBRACKET();
645 IntConstContext *intConst();
646 antlr4::tree::TerminalNode *RBRACKET();
647 antlr4::tree::TerminalNode *LCURLY();
648 antlr4::tree::TerminalNode *RCURLY();
649 std::vector<RigidbodystatementContext *> rigidbodystatement();
650 RigidbodystatementContext* rigidbodystatement(size_t i);
651
652 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
653 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
654
655 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
656
657 };
658
659 RigidbodyblockContext* rigidbodyblock();
660
661 class RigidbodystatementContext : public antlr4::ParserRuleContext {
662 public:
663 RigidbodystatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
664 virtual size_t getRuleIndex() const override;
665 AssignmentContext *assignment();
666 antlr4::tree::TerminalNode *MEMBERS();
667 antlr4::tree::TerminalNode *LPAREN();
668 InttupleContext *inttuple();
669 antlr4::tree::TerminalNode *RPAREN();
670 antlr4::tree::TerminalNode *SEMICOLON();
671
672 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
673 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
674
675 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
676
677 };
678
679 RigidbodystatementContext* rigidbodystatement();
680
681 class CutoffgroupblockContext : public antlr4::ParserRuleContext {
682 public:
683 CutoffgroupblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
684 virtual size_t getRuleIndex() const override;
685 antlr4::tree::TerminalNode *CUTOFFGROUP();
686 antlr4::tree::TerminalNode *LCURLY();
687 antlr4::tree::TerminalNode *RCURLY();
688 antlr4::tree::TerminalNode *LBRACKET();
689 IntConstContext *intConst();
690 antlr4::tree::TerminalNode *RBRACKET();
691 std::vector<CutoffgroupstatementContext *> cutoffgroupstatement();
692 CutoffgroupstatementContext* cutoffgroupstatement(size_t i);
693
694 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
695 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
696
697 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
698
699 };
700
701 CutoffgroupblockContext* cutoffgroupblock();
702
703 class CutoffgroupstatementContext : public antlr4::ParserRuleContext {
704 public:
705 CutoffgroupstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
706 virtual size_t getRuleIndex() const override;
707 AssignmentContext *assignment();
708 antlr4::tree::TerminalNode *MEMBERS();
709 antlr4::tree::TerminalNode *LPAREN();
710 InttupleContext *inttuple();
711 antlr4::tree::TerminalNode *RPAREN();
712 antlr4::tree::TerminalNode *SEMICOLON();
713
714 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
715 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
716
717 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
718
719 };
720
721 CutoffgroupstatementContext* cutoffgroupstatement();
722
723 class NodesblockContext : public antlr4::ParserRuleContext {
724 public:
725 NodesblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
726 virtual size_t getRuleIndex() const override;
727 antlr4::tree::TerminalNode *NODES();
728 antlr4::tree::TerminalNode *LCURLY();
729 antlr4::tree::TerminalNode *RCURLY();
730 antlr4::tree::TerminalNode *LBRACKET();
731 IntConstContext *intConst();
732 antlr4::tree::TerminalNode *RBRACKET();
733 std::vector<NodesstatementContext *> nodesstatement();
734 NodesstatementContext* nodesstatement(size_t i);
735
736 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
737 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
738
739 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
740
741 };
742
743 NodesblockContext* nodesblock();
744
745 class NodesstatementContext : public antlr4::ParserRuleContext {
746 public:
747 NodesstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
748 virtual size_t getRuleIndex() const override;
749 AssignmentContext *assignment();
750 antlr4::tree::TerminalNode *MEMBERS();
751 antlr4::tree::TerminalNode *LPAREN();
752 InttupleContext *inttuple();
753 antlr4::tree::TerminalNode *RPAREN();
754 antlr4::tree::TerminalNode *SEMICOLON();
755
756 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
757 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
758
759 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
760
761 };
762
763 NodesstatementContext* nodesstatement();
764
765 class FragmentblockContext : public antlr4::ParserRuleContext {
766 public:
767 FragmentblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
768 virtual size_t getRuleIndex() const override;
769 antlr4::tree::TerminalNode *FRAGMENT();
770 antlr4::tree::TerminalNode *LCURLY();
771 antlr4::tree::TerminalNode *RCURLY();
772 std::vector<FragmentstatementContext *> fragmentstatement();
773 FragmentstatementContext* fragmentstatement(size_t i);
774
775 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
776 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
777
778 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
779
780 };
781
782 FragmentblockContext* fragmentblock();
783
784 class FragmentstatementContext : public antlr4::ParserRuleContext {
785 public:
786 FragmentstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
787 virtual size_t getRuleIndex() const override;
788 AssignmentContext *assignment();
789 AtomblockContext *atomblock();
790 BondblockContext *bondblock();
791 BendblockContext *bendblock();
792 TorsionblockContext *torsionblock();
793 InversionblockContext *inversionblock();
794 RigidbodyblockContext *rigidbodyblock();
795 CutoffgroupblockContext *cutoffgroupblock();
796 ConstraintblockContext *constraintblock();
797 NodesblockContext *nodesblock();
798
799 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
800 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
801
802 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
803
804 };
805
806 FragmentstatementContext* fragmentstatement();
807
808 class ConstraintblockContext : public antlr4::ParserRuleContext {
809 public:
810 ConstraintblockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
811 virtual size_t getRuleIndex() const override;
812 antlr4::tree::TerminalNode *CONSTRAINT();
813 antlr4::tree::TerminalNode *LCURLY();
814 antlr4::tree::TerminalNode *RCURLY();
815 antlr4::tree::TerminalNode *LBRACKET();
816 IntConstContext *intConst();
817 antlr4::tree::TerminalNode *RBRACKET();
818 std::vector<ConstraintstatementContext *> constraintstatement();
819 ConstraintstatementContext* constraintstatement(size_t i);
820
821 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
822 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
823
824 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
825
826 };
827
828 ConstraintblockContext* constraintblock();
829
830 class ConstraintstatementContext : public antlr4::ParserRuleContext {
831 public:
832 ConstraintstatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
833 virtual size_t getRuleIndex() const override;
834 AssignmentContext *assignment();
835 antlr4::tree::TerminalNode *MEMBERS();
836 antlr4::tree::TerminalNode *LPAREN();
837 InttupleContext *inttuple();
838 antlr4::tree::TerminalNode *RPAREN();
839 antlr4::tree::TerminalNode *SEMICOLON();
840
841 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
842 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
843
844 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
845
846 };
847
848 ConstraintstatementContext* constraintstatement();
849
850 class SequencestringContext : public antlr4::ParserRuleContext {
851 public:
852 SequencestringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
853 virtual size_t getRuleIndex() const override;
854 antlr4::tree::TerminalNode *SEQUENCE();
855 antlr4::tree::TerminalNode *ASSIGNEQUAL();
856 ConstantContext *constant();
857 antlr4::tree::TerminalNode *SEMICOLON();
858
859 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
860 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
861
862 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
863
864 };
865
866 SequencestringContext* sequencestring();
867
868 class DoubleNumberTupleContext : public antlr4::ParserRuleContext {
869 public:
870 DoubleNumberTupleContext(antlr4::ParserRuleContext *parent, size_t invokingState);
871 virtual size_t getRuleIndex() const override;
872 std::vector<DoubleNumberContext *> doubleNumber();
873 DoubleNumberContext* doubleNumber(size_t i);
874 std::vector<antlr4::tree::TerminalNode *> COMMA();
875 antlr4::tree::TerminalNode* COMMA(size_t i);
876
877 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
878 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
879
880 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
881
882 };
883
884 DoubleNumberTupleContext* doubleNumberTuple();
885
886 class InttupleContext : public antlr4::ParserRuleContext {
887 public:
888 InttupleContext(antlr4::ParserRuleContext *parent, size_t invokingState);
889 virtual size_t getRuleIndex() const override;
890 std::vector<IntConstContext *> intConst();
891 IntConstContext* intConst(size_t i);
892 std::vector<antlr4::tree::TerminalNode *> COMMA();
893 antlr4::tree::TerminalNode* COMMA(size_t i);
894
895 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
896 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
897
898 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
899
900 };
901
902 InttupleContext* inttuple();
903
904 class IntConstContext : public antlr4::ParserRuleContext {
905 public:
906 IntConstContext(antlr4::ParserRuleContext *parent, size_t invokingState);
907 virtual size_t getRuleIndex() const override;
908 antlr4::tree::TerminalNode *NUM_INT();
909 antlr4::tree::TerminalNode *NUM_LONG();
910
911 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
912 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
913
914 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
915
916 };
917
918 IntConstContext* intConst();
919
920 class DoubleNumberContext : public antlr4::ParserRuleContext {
921 public:
922 DoubleNumberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
923 virtual size_t getRuleIndex() const override;
924 IntConstContext *intConst();
925 FloatConstContext *floatConst();
926
927 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
928 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
929
930 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
931
932 };
933
934 DoubleNumberContext* doubleNumber();
935
936 class FloatConstContext : public antlr4::ParserRuleContext {
937 public:
938 FloatConstContext(antlr4::ParserRuleContext *parent, size_t invokingState);
939 virtual size_t getRuleIndex() const override;
940 antlr4::tree::TerminalNode *NUM_FLOAT();
941 antlr4::tree::TerminalNode *NUM_DOUBLE();
942
943 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
944 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
945
946 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
947
948 };
949
950 FloatConstContext* floatConst();
951
952 class VectorConstContext : public antlr4::ParserRuleContext {
953 public:
954 VectorConstContext(antlr4::ParserRuleContext *parent, size_t invokingState);
955 virtual size_t getRuleIndex() const override;
956 antlr4::tree::TerminalNode *LPAREN();
957 DoubleNumberTupleContext *doubleNumberTuple();
958 antlr4::tree::TerminalNode *RPAREN();
959
960 virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
961 virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
962
963 virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
964
965 };
966
967 VectorConstContext* vectorConst();
968
969
970 // By default the static state used to implement the parser is lazily initialized during the first
971 // call to the constructor. You can call this function if you wish to initialize the static state
972 // ahead of time.
973 static void initialize();
974
975private:
976};
977