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;
    std::vector<RealType> dvec;
}    
    : ival=intConst {blockStack.top()->assign(id->getText(), ival);}
    | dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
    | 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);
        }
    | #(LPAREN dvec=doubleNumberTuple RPAREN) 
        { 
            blockStack.top()->assign(id->getText(), dvec);
        }
    ;
            

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