src/mdParser/MDTreeParser.g

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

options
{
        k = 3;
        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
          ;


assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
            ;
            
constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]    
            : signedIntOrFloat[#id]
            | 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);
                                 }
            ;
            
signedIntOrFloat [ANTLR_USE_NAMESPACE(antlr)RefAST id]  
{
  int ival;
  double dval;
}
              : #(MINUS (icMinus:intConst {ival = lexi_cast<int>(icMinus->getText()); ival = -ival; blockStack.top()->assign(id->getText(), ival);}
                | fcMinus:floatConst) {dval = lexi_cast<double>(fcMinus->getText());dval = -dval;  blockStack.top()->assign(id->getText(), dval);}
                ) 
              | (ic:intConst {ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival);}
                | fc:floatConst {dval = lexi_cast<double>(fc->getText());  blockStack.top()->assign(id->getText(), dval);} 
                )               
              ;

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);}
                  ;
  
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
                  | rigidbodyblock
                  | cutoffgroupblock
                  | fragmentblock
                  ;

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<double> dvec;
AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());

}
              : assignment
              | #(POSITION dvec=signedNumberTuple) {currAtomStamp->setPosition(dvec);}
              | #(ORIENTATION dvec=signedNumberTuple) {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);}
              ;

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
              ;


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

protected
intConst returns [int ival]
        : oival:OCTALINT {ival = lexi_cast<int>(oival->getText());} 
        | dival:DECIMALINT {ival = lexi_cast<int>(dival->getText());}
        | hival:HEXADECIMALINT {ival = lexi_cast<int>(hival->getText());}
        ;

protected
signedNumber  returns [double dval]
              : #(MINUS (icMinus:intConst {dval = lexi_cast<double>(icMinus->getText()); dval = -dval;}
                | fcMinus:floatConst) {dval = lexi_cast<double>(fcMinus->getText());dval = -dval;}
                ) 
              | (ic:intConst {dval = lexi_cast<double>(ic->getText());}
                | fc:floatConst {dval = lexi_cast<double>(fc->getText());} 
                )               
              ;
              
protected
floatConst returns [double dval]
        : d1:FLOATONE {dval = lexi_cast<double>(d1->getText());}  
        | d2:FLOATTWO {dval = lexi_cast<double>(d2->getText());} 
        ;
        
Revision:	770
Committed:	Fri Dec 2 15:38:03 2005 UTC (19 years, 11 months ago) by tim
File size:	10387 byte(s)
Log Message:	End of the Link --> List Return of the Oject-Oriented replace yacc/lex parser with antlr parser
#	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			using namespace oopse;
8			}
9			options
10			{
11			language = "Cpp";
12			}
13
14			class MDTreeParser extends TreeParser;
15
16			options
17			{
18			k = 3;
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			;
42
43
44			assignment : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
45			;
46
47			constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
48			: signedIntOrFloat[#id]
49			\| str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
50			\| str2:StringLiteral { std::string s = str2->getText();
51			s = s.substr(1, s.length()-2);
52			blockStack.top()->assign(id->getText(),s);
53			}
54			;
55
56			signedIntOrFloat [ANTLR_USE_NAMESPACE(antlr)RefAST id]
57			{
58			int ival;
59			double dval;
60			}
61			: #(MINUS (icMinus:intConst {ival = lexi_cast<int>(icMinus->getText()); ival = -ival; blockStack.top()->assign(id->getText(), ival);}
62			\| fcMinus:floatConst) {dval = lexi_cast<double>(fcMinus->getText());dval = -dval; blockStack.top()->assign(id->getText(), dval);}
63			)
64			\| (ic:intConst {ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival);}
65			\| fc:floatConst {dval = lexi_cast<double>(fc->getText()); blockStack.top()->assign(id->getText(), dval);}
66			)
67			;
68
69			componentblock : #(COMPONENT {Component* currComponet = new Component(); blockStack.push(currComponet);}
70			(assignment)*
71			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
72			;
73
74			zconstraintblock : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
75			(assignment)*
76			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
77			;
78
79			moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
80			(moleculestatement)*
81			ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
82			;
83
84			moleculestatement : assignment
85			\| atomblock
86			\| bondblock
87			\| bendblock
88			\| torsionblock
89			\| rigidbodyblock
90			\| cutoffgroupblock
91			\| fragmentblock
92			;
93
94			atomblock
95			{
96			int index;
97			}
98			: #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);}
99			(atomstatement)*
100			ENDBLOCK ) {
101			blockStack.top()->validate();
102			blockStack.pop();
103			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
104			currMoleculeStamp->addAtomStamp(currAtomStamp);
105			}
106			;
107
108			atomstatement
109			{
110			vector<double> dvec;
111			AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
112
113			}
114			: assignment
115			\| #(POSITION dvec=signedNumberTuple) {currAtomStamp->setPosition(dvec);}
116			\| #(ORIENTATION dvec=signedNumberTuple) {currAtomStamp->setOrientation(dvec);}
117			;
118
119
120			bondblock : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
121			(bondstatement)*
122			ENDBLOCK ) {
123			blockStack.pop();
124			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
125			currMoleculeStamp->addBondStamp(currBondStamp);
126			}
127			;
128
129			bondstatement
130			{
131			vector<int> ivec;
132			BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
133			}
134			: assignment
135			\| #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
136			;
137
138			bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
139			(bendstatement)*
140			ENDBLOCK) {
141			blockStack.top()->validate();
142			blockStack.pop();
143			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
144			currMoleculeStamp->addBendStamp(currBendStamp);
145			}
146			;
147
148			bendstatement
149			{
150			vector<int> ivec;
151			BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
152			}
153			: assignment
154			\| #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
155			;
156
157			torsionblock : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
158			(torsionstatement)*
159			ENDBLOCK ) {
160			blockStack.top()->validate();
161			blockStack.pop();
162			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
163			currMoleculeStamp->addTorsionStamp(currTorsionStamp);
164			}
165			;
166
167			torsionstatement
168			{
169			vector<int> ivec;
170			TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
171			}
172			: assignment
173			\| #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
174			;
175
176			rigidbodyblock
177			{
178			int index;
179			}
180			: #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
181			(rigidbodystatement)*
182			ENDBLOCK ) {
183			blockStack.top()->validate();
184			blockStack.pop();
185			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
186			currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
187			}
188			;
189
190			rigidbodystatement
191			{
192			vector<int> ivec;
193			RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
194			}
195			: assignment
196			\| #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
197			;
198
199			cutoffgroupblock : #(CUTOFFGROUP {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
200			(cutoffgroupstatement)*
201			ENDBLOCK ) {
202			blockStack.top()->validate();
203			blockStack.pop();
204			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
205			currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
206			}
207			;
208
209			cutoffgroupstatement
210			{
211			vector<int> ivec;
212			CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
213			}
214			: assignment
215			\| #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}
216			;
217
218			fragmentblock {int ival;}
219			: #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
220			(fragmentstatement)*
221			ENDBLOCK) {
222			blockStack.top()->validate();
223			blockStack.pop();
224			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
225			currMoleculeStamp->addFragmentStamp(currFragmentStamp);
226			}
227			;
228
229			fragmentstatement : assignment
230			;
231
232
233
234			signedNumberTuple returns [vector<double> dvec]
235			{
236			double dval;
237			}
238			: (dval=signedNumber {dvec.push_back(dval);})+
239			;
240
241			inttuple returns [vector<int> ivec]
242			{
243			int ival;
244			}
245			: (ival=intConst {ivec.push_back(ival);})+
246			;
247
248			protected
249			intConst returns [int ival]
250			: oival:OCTALINT {ival = lexi_cast<int>(oival->getText());}
251			\| dival:DECIMALINT {ival = lexi_cast<int>(dival->getText());}
252			\| hival:HEXADECIMALINT {ival = lexi_cast<int>(hival->getText());}
253			;
254
255			protected
256			signedNumber returns [double dval]
257			: #(MINUS (icMinus:intConst {dval = lexi_cast<double>(icMinus->getText()); dval = -dval;}
258			\| fcMinus:floatConst) {dval = lexi_cast<double>(fcMinus->getText());dval = -dval;}
259			)
260			\| (ic:intConst {dval = lexi_cast<double>(ic->getText());}
261			\| fc:floatConst {dval = lexi_cast<double>(fc->getText());}
262			)
263			;
264
265			protected
266			floatConst returns [double dval]
267			: d1:FLOATONE {dval = lexi_cast<double>(d1->getText());}
268			\| d2:FLOATTWO {dval = lexi_cast<double>(d2->getText());}
269			;
270