src/mdParser/MDTreeParser.g

header
{
#include <stack>
#include "io/Globals.hpp"
#include "utils/StringUtils.hpp"
using namespace std;
using namespace OpenMD;
}
options
  {
  language = "Cpp";
  }
                     
class MDTreeParser extends TreeParser;

options
{
        k = 1;
        importVocab = MD;
}
{
  public:
    Globals* walkTree(ANTLR_USE_NAMESPACE(antlr)RefAST tree)
    {
      currConf = new Globals;
      blockStack.push(currConf);
      mdfile(tree);
      return currConf;
    }
  private:
    Globals* currConf;
    stack<DataHolder*> blockStack;    
}
mdfile  : (statement)* {blockStack.top()->validate(); blockStack.pop();}
        ;

statement : assignment
    | componentblock
    | moleculeblock
    | zconstraintblock
    | restraintblock
    | flucqblock
    | rnemdblock
    | minimizerblock
    ;

assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
            ;
            
constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
{
    int ival;
    RealType dval, x, y, z;
    Vector3d dvec;
}    
    : ival=intConst {blockStack.top()->assign(id->getText(), ival);}
    | dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
    | #(LPAREN x=doubleNumber COMMA y=doubleNumber COMMA z=doubleNumber RPAREN) 
        {   dvec.x() = x; 
            dvec.y() = y; 
            dvec.z() = z; 
            blockStack.top()->assign(id->getText(), dvec);
        }
    | str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
    | str2:StringLiteral {std::string s =  str2->getText();
            s = s.substr(1, s.length()-2);
            blockStack.top()->assign(id->getText(),s);
        }
    ;
            

componentblock  : #(COMPONENT  {Component* currComponet = new Component(); blockStack.push(currComponet);}
                      (assignment)* 
                       ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
                ;
    
zconstraintblock  : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
                        (assignment)* 
                         ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
                  ;

restraintblock  : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
                        (assignment)* 
                         ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
                  ;
  
flucqblock  : #(FLUCQ  {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
                      (assignment)* 
                       ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
                ;

rnemdblock  : #(RNEMD  {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
                      (assignment)* 
                       ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
                ;

minimizerblock  : #(MINIMIZER  {MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);}
                      (assignment)* 
                       ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);}
                ;


moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
                    (moleculestatement)* 
                     ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
              ;

moleculestatement : assignment
                  | atomblock
                  | bondblock
                  | bendblock
                  | torsionblock
                  | inversionblock
                  | rigidbodyblock
                  | cutoffgroupblock
                  | fragmentblock
                  | constraintblock
                  ;

atomblock 
{
  int index;
}
          : #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);} 
                  (atomstatement)* 
                  ENDBLOCK ) {
                                blockStack.top()->validate();
                                blockStack.pop(); 
                                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                currMoleculeStamp->addAtomStamp(currAtomStamp); 
                             }
          ;

atomstatement 
{
vector<RealType> dvec;
AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());

}
              : assignment
              | #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
              | #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
              ;

                      
bondblock : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
                (bondstatement)* 
                 ENDBLOCK )  {
                                blockStack.pop(); 
                                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                currMoleculeStamp->addBondStamp(currBondStamp); 
                             }
          ;

bondstatement 
{
  vector<int> ivec;
  BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
              ;

bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
                  (bendstatement)* 
                   ENDBLOCK)  {
                                blockStack.top()->validate();
                                blockStack.pop(); 
                                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                currMoleculeStamp->addBendStamp(currBendStamp); 
                             }
          ;

bendstatement 
{
  vector<int> ivec;
  BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
              ;

torsionblock  : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
                   (torsionstatement)*
                    ENDBLOCK )  {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addTorsionStamp(currTorsionStamp); 
                                }
          ;

torsionstatement
{
  vector<int> ivec;
  TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
}  
              : assignment
              | #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
              ;

inversionblock  : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
                   (inversionstatement)*
                    ENDBLOCK )  {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addInversionStamp(currInversionStamp); 
                                }
          ;

inversionstatement
{
  int icent;
  vector<int> ivec;
  InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
}  
              : assignment
              | #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
              | #(SATELLITES ivec=inttuple) {currInversionStamp->setSatellites(ivec);}
              ;

rigidbodyblock
{
int index;
}
              : #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
                        (rigidbodystatement)* 
                        ENDBLOCK )  {
                                      blockStack.top()->validate();
                                      blockStack.pop(); 
                                      MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                      currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); 
                                    }
                ;

rigidbodystatement  
{
  vector<int> ivec;
  RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
              ;

cutoffgroupblock  : #(CUTOFFGROUP  {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
                          (cutoffgroupstatement)* 
                           ENDBLOCK ) {
                                        blockStack.top()->validate();
                                        blockStack.pop(); 
                                        MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                        currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp); 
                                      }
                  ;

cutoffgroupstatement
{
  vector<int> ivec;
  CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
}  
              : assignment
              | #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}             
              ;

fragmentblock {int ival;}
               : #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
                      (fragmentstatement)* 
                      ENDBLOCK) {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addFragmentStamp(currFragmentStamp); 
                                }
              ;

fragmentstatement : assignment
    ;

constraintblock : #(CONSTRAINT {ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);}
                (constraintstatement)* 
                 ENDBLOCK )  {
                                blockStack.pop(); 
                                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                currMoleculeStamp->addConstraintStamp(currConstraintStamp); 
                             }
          ;

constraintstatement 
{
  vector<int> ivec;
  ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currConstraintStamp->setMembers(ivec);}
              ;

              
doubleNumberTuple returns [vector<RealType> dvec]
{
    RealType dval;
}   
    : (dval=doubleNumber {dvec.push_back(dval);})+  
    ;


inttuple returns [vector<int> ivec]
{
    int ival;
}
    : (ival=intConst {ivec.push_back(ival);})+ 
    ;

protected
intConst returns [int ival]
    : i1:NUM_INT {ival = lexi_cast<int>(i1->getText());} 
    | i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
    ;

protected
doubleNumber returns [RealType dval]
    : ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
    | fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}         
    ;
              
protected
floatConst returns [RealType dval]
    : d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}  
    | d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());} 
    ;
  
Revision:	1979
Committed:	Sat Apr 5 20:56:01 2014 UTC (11 years, 1 month ago) by gezelter
File size:	12680 byte(s)
Log Message:	* Changed the stdDev printouts in RNEMD stats to the 95% confidence intervals * Added the ability to specify non-bonded constraints in a molecule * Added the ability to do selection offsets in the pAngle staticProps module
#	User	Rev	Content
1	tim	770	header
2			{
3			#include <stack>
4			#include "io/Globals.hpp"
5			#include "utils/StringUtils.hpp"
6			using namespace std;
7	gezelter	1390	using namespace OpenMD;
8	tim	770	}
9			options
10			{
11			language = "Cpp";
12			}
13
14			class MDTreeParser extends TreeParser;
15
16			options
17			{
18	gezelter	1277	k = 1;
19	tim	770	importVocab = MD;
20			}
21			{
22			public:
23			Globals* walkTree(ANTLR_USE_NAMESPACE(antlr)RefAST tree)
24			{
25			currConf = new Globals;
26			blockStack.push(currConf);
27			mdfile(tree);
28			return currConf;
29			}
30			private:
31			Globals* currConf;
32			stack<DataHolder*> blockStack;
33			}
34			mdfile : (statement)* {blockStack.top()->validate(); blockStack.pop();}
35			;
36
37			statement : assignment
38	gezelter	1782	\| componentblock
39			\| moleculeblock
40			\| zconstraintblock
41			\| restraintblock
42			\| flucqblock
43			\| rnemdblock
44			\| minimizerblock
45			;
46	tim	770
47			assignment : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
48			;
49
50	tim	814	constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
51			{
52	gezelter	1782	int ival;
53			RealType dval, x, y, z;
54			Vector3d dvec;
55	tim	814	}
56	gezelter	1782	: ival=intConst {blockStack.top()->assign(id->getText(), ival);}
57			\| dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
58			\| #(LPAREN x=doubleNumber COMMA y=doubleNumber COMMA z=doubleNumber RPAREN)
59			{ dvec.x() = x;
60			dvec.y() = y;
61			dvec.z() = z;
62			blockStack.top()->assign(id->getText(), dvec);
63			}
64			\| str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
65			\| str2:StringLiteral {std::string s = str2->getText();
66			s = s.substr(1, s.length()-2);
67			blockStack.top()->assign(id->getText(),s);
68			}
69			;
70	tim	770
71
72			componentblock : #(COMPONENT {Component* currComponet = new Component(); blockStack.push(currComponet);}
73			(assignment)*
74			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
75			;
76
77			zconstraintblock : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
78			(assignment)*
79			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
80			;
81	cli2	1360
82			restraintblock : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
83			(assignment)*
84			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
85			;
86	tim	770
87	gezelter	1782	flucqblock : #(FLUCQ {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
88			(assignment)*
89			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
90			;
91
92			rnemdblock : #(RNEMD {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
93			(assignment)*
94			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
95			;
96
97			minimizerblock : #(MINIMIZER {MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);}
98			(assignment)*
99			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);}
100			;
101
102
103	tim	770	moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
104			(moleculestatement)*
105			ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
106			;
107
108			moleculestatement : assignment
109			\| atomblock
110			\| bondblock
111			\| bendblock
112			\| torsionblock
113	cli2	1275	\| inversionblock
114	tim	770	\| rigidbodyblock
115			\| cutoffgroupblock
116			\| fragmentblock
117	gezelter	1979	\| constraintblock
118	tim	770	;
119
120			atomblock
121			{
122			int index;
123			}
124			: #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);}
125			(atomstatement)*
126			ENDBLOCK ) {
127			blockStack.top()->validate();
128			blockStack.pop();
129			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
130			currMoleculeStamp->addAtomStamp(currAtomStamp);
131			}
132			;
133
134			atomstatement
135			{
136	tim	963	vector<RealType> dvec;
137	tim	770	AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
138
139			}
140			: assignment
141	tim	814	\| #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
142			\| #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
143	tim	770	;
144
145
146			bondblock : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
147			(bondstatement)*
148			ENDBLOCK ) {
149			blockStack.pop();
150			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
151			currMoleculeStamp->addBondStamp(currBondStamp);
152			}
153			;
154
155			bondstatement
156			{
157			vector<int> ivec;
158			BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
159			}
160			: assignment
161			\| #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
162			;
163
164			bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
165			(bendstatement)*
166			ENDBLOCK) {
167			blockStack.top()->validate();
168			blockStack.pop();
169			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
170			currMoleculeStamp->addBendStamp(currBendStamp);
171			}
172			;
173
174			bendstatement
175			{
176			vector<int> ivec;
177			BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
178			}
179			: assignment
180			\| #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
181			;
182
183			torsionblock : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
184			(torsionstatement)*
185			ENDBLOCK ) {
186			blockStack.top()->validate();
187			blockStack.pop();
188			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
189			currMoleculeStamp->addTorsionStamp(currTorsionStamp);
190			}
191			;
192
193			torsionstatement
194			{
195			vector<int> ivec;
196			TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
197			}
198			: assignment
199			\| #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
200			;
201
202	cli2	1275	inversionblock : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
203			(inversionstatement)*
204			ENDBLOCK ) {
205			blockStack.top()->validate();
206			blockStack.pop();
207			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
208			currMoleculeStamp->addInversionStamp(currInversionStamp);
209			}
210			;
211
212			inversionstatement
213			{
214			int icent;
215	gezelter	1902	vector<int> ivec;
216	cli2	1275	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
217			}
218			: assignment
219			\| #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
220	gezelter	1902	\| #(SATELLITES ivec=inttuple) {currInversionStamp->setSatellites(ivec);}
221	cli2	1275	;
222
223	tim	770	rigidbodyblock
224			{
225			int index;
226			}
227			: #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
228			(rigidbodystatement)*
229			ENDBLOCK ) {
230			blockStack.top()->validate();
231			blockStack.pop();
232			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
233			currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
234			}
235			;
236
237			rigidbodystatement
238			{
239			vector<int> ivec;
240			RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
241			}
242			: assignment
243			\| #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
244			;
245
246			cutoffgroupblock : #(CUTOFFGROUP {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
247			(cutoffgroupstatement)*
248			ENDBLOCK ) {
249			blockStack.top()->validate();
250			blockStack.pop();
251			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
252			currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
253			}
254			;
255
256			cutoffgroupstatement
257			{
258			vector<int> ivec;
259			CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
260			}
261			: assignment
262			\| #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}
263			;
264
265			fragmentblock {int ival;}
266			: #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
267			(fragmentstatement)*
268			ENDBLOCK) {
269			blockStack.top()->validate();
270			blockStack.pop();
271			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
272			currMoleculeStamp->addFragmentStamp(currFragmentStamp);
273			}
274			;
275
276			fragmentstatement : assignment
277	gezelter	1782	;
278	tim	770
279	gezelter	1979	constraintblock : #(CONSTRAINT {ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);}
280			(constraintstatement)*
281			ENDBLOCK ) {
282			blockStack.pop();
283			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
284			currMoleculeStamp->addConstraintStamp(currConstraintStamp);
285			}
286			;
287	tim	770
288	gezelter	1979	constraintstatement
289			{
290			vector<int> ivec;
291			ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
292			}
293			: assignment
294			\| #(MEMBERS ivec=inttuple) {currConstraintStamp->setMembers(ivec);}
295			;
296
297	tim	770
298	gezelter	1782	doubleNumberTuple returns [vector<RealType> dvec]
299	tim	770	{
300	gezelter	1782	RealType dval;
301			}
302			: (dval=doubleNumber {dvec.push_back(dval);})+
303			;
304
305
306			inttuple returns [vector<int> ivec]
307	tim	770	{
308	gezelter	1782	int ival;
309	tim	770	}
310	gezelter	1782	: (ival=intConst {ivec.push_back(ival);})+
311			;
312	tim	770
313			protected
314			intConst returns [int ival]
315	gezelter	1782	: i1:NUM_INT {ival = lexi_cast<int>(i1->getText());}
316			\| i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
317			;
318	tim	770
319			protected
320	gezelter	1782	doubleNumber returns [RealType dval]
321			: ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
322			\| fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}
323			;
324	tim	770
325			protected
326	tim	963	floatConst returns [RealType dval]
327	gezelter	1782	: d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}
328			\| d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());}
329			;
330