ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/selection/SelectionCompiler.hpp

Comparing trunk/src/selection/SelectionCompiler.hpp (file contents):
Revision 278 by tim, Tue Feb 1 22:49:23 2005 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 6 | Line 6
6		* redistribute this software in source and binary code form, provided
7		* that the following conditions are met:
8		*
9	<	* 1. Acknowledgement of the program authors must be made in any
10	<	*    publication of scientific results based in part on use of the
11	<	*    program.  An acceptable form of acknowledgement is citation of
12	<	*    the article in which the program was described (Matthew
13	<	*    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14	<	*    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15	<	*    Parallel Simulation Engine for Molecular Dynamics,"
16	<	*    J. Comput. Chem. 26, pp. 252-271 (2005))
17	<	*
18	<	* 2. Redistributions of source code must retain the above copyright
9	>	* 1. Redistributions of source code must retain the above copyright
10		*    notice, this list of conditions and the following disclaimer.
11		*
12	<	* 3. Redistributions in binary form must reproduce the above copyright
12	>	* 2. Redistributions in binary form must reproduce the above copyright
13		*    notice, this list of conditions and the following disclaimer in the
14		*    documentation and/or other materials provided with the
15		*    distribution.
#	Line 37 | Line 28
28		* arising out of the use of or inability to use software, even if the
29		* University of Notre Dame has been advised of the possibility of
30		* such damages.
31	+	*
32	+	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	+	* research, please cite the appropriate papers when you publish your
34	+	* work.  Good starting points are:
35	+	*
36	+	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	+	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	+	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	+	* [4]  Vardeman & Gezelter, in progress (2009).
40		*/
41
42		#ifndef SELECTION_SELECTIONCOMPILER_HPP
43		#define SELECTION_SELECTIONCOMPILER_HPP
44	+	#include <iostream>
45		#include <string>
46		#include <vector>
46	–	namespace oopse {
47
48	+	#include "selection/SelectionToken.hpp"
49	+	#include "selection/TokenMap.hpp"
50	+	#include "brains/SimInfo.hpp"
51
52	<	/**
50	<	* @class SelectionCompiler SelectionCompiler.hpp "selection/SelectionCompiler.hpp"
51	<	* @brief compile a selection script to tokens
52	<	* @todo document
53	<	* <pre>
52	>	namespace OpenMD {
53
55	–	expression       :: = clauseOr
54
55	<	clauseOr         ::= clauseAnd {OR clauseAnd}*
55	>	/**
56	>	* @class SelectionCompiler SelectionCompiler.hpp "selection/SelectionCompiler.hpp"
57	>	* @brief compile a selection script to tokens
58	>	* @todo document
59	>	* <pre>
60
61	<	clauseAnd        ::= clauseNot {AND clauseNot}*
61	>	expression       :: = clauseOr
62
63	<	clauseNot        ::= NOT clauseNot | clausePrimitive
63	>	clauseOr         ::= clauseAnd {OR clauseAnd}*
64
65	<	clausePrimitive  ::= clauseComparator |
64	<	clauseWithin |
65	<	clauseChemObject |
66	<	none | all |
67	<	( clauseOr )
65	>	clauseAnd        ::= clauseNot {AND clauseNot}*
66
67	<	clauseComparator ::= atomproperty comparatorop integer
67	>	clauseNot        ::= NOT clauseNot | clausePrimitive
68
69	<	clauseWithin     ::= WITHIN ( clauseDistance , expression )
69	>	clausePrimitive  ::= clauseComparator |
70	>	clauseWithin |
71	>	clauseName |
72	>	none | all |
73	>	( clauseOr )
74
75	<	clauseDistance   ::= integer | decimal
74	<
75	<	clauseChemObject::= {clauseMolecule} | {clauseStuntDouble}
75	>	clauseComparator ::= atomproperty comparatorop integer
76
77	<	clauseMolecule ::= {clauseMolName} | {clauseMolIndex}
77	>	clauseWithin     ::= WITHIN ( clauseDistance , expression )
78
79	<	clauseMolName ::= molname clauseName
80	<
81	<	clauseName::= *|string
79	>	clauseDistance   ::= integer | decimal
80	>
81	>	clauseName::= *|string{.string{.string}}
82
83	–	clauseMolIndex ::= molindex clauseIndex
84	–
85	–	clauseIndex ::= integer {- integer }
86	–
87	–	clauseStuntDouble ::= {clauseStuntDoubleName} | {clauseStuntDoubleIndex}
83
84	<	clauseStuntDoubleName ::= name clauseName
85	<
86	<	clauseStuntDoubleIndex ::= index clauseIndex
87	<
88	<	* </pre>
94	<	*/
95	<	class SelectionCompiler{
96	<	public:
97	<	bool compile(const std::string& filename, const std::string& script );
84	>	* </pre>
85	>	*/
86	>	class SelectionCompiler{
87	>	public:
88	>	bool compile(const std::string& filename, const std::string& script );
89
90
91	<	std::vector<int> getLineNumbers() {
92	<	return lineNumbers;
93	<	}
91	>	std::vector<int> getLineNumbers() {
92	>	return lineNumbers;
93	>	}
94
95	<	std::vector<int> getLineIndices() {
96	<	return lineIndices;
97	<	}
95	>	std::vector<int> getLineIndices() {
96	>	return lineIndices;
97	>	}
98
99	<	std::vector<std::vector<Token> > getAatokenCompiled() {
100	<	return aatokenCompiled;
101	<	}
99	>	std::vector<std::vector<Token> > getAatokenCompiled() {
100	>	return aatokenCompiled;
101	>	}
102
103	<	std::string getErrorMessage() {
104	<	std::string strError = errorMessage;
105	<	strError += " : " + errorLine + "\n";
103	>	std::string getErrorMessage() {
104	>	std::string strError = errorMessage;
105	>	strError += " : " + errorLine + "\n";
106
107	<	if (!filename.empty()) {
108	<	strError += filename;
109	<	}
107	>	if (!filename.empty()) {
108	>	strError += filename;
109	>	}
110
111	<	strError += " line#" + lineCurrent;
112	<	return strError;
122	<	}
111	>	return strError;
112	>	}
113
114
115	<	private:
115	>	private:
116
117	<	bool internalcompile();
117	>	bool internalCompile();
118
119
120	<	bool lookingAtLeadingWhitespace();
121	<	bool lookingAtComment();
122	<	bool lookingAtEndOfLine();
123	<	bool lookingAtEndOfStatement();
124	<	bool lookingAtString();
120	>	bool lookingAtLeadingWhitespace();
121	>	//bool lookingAtComment();
122	>	bool lookingAtEndOfLine();
123	>	bool lookingAtEndOfStatement();
124	>	bool lookingAtString();
125	>	bool lookingAtDecimal(bool allowNegative);
126	>	bool lookingAtInteger(bool allowNegative);
127	>	bool lookingAtLookupToken();
128	>	bool lookingAtSpecialString();
129
130	+	std::string getUnescapedStringLiteral();
131	+	int getHexitValue(char ch);
132
133	<	bool compileCommand(const std::vector<vector>&);
133	>	bool compileCommand(const std::vector<Token>& ltoken);
134	>	bool compileExpression();
135	>	bool compileExpression(int itoken);
136
137	<	bool clauseOr();
138	<	bool clauseAnd();
139	<	bool clauseNot();
140	<	bool clausePrimitive();
141	<	bool clauseWithin();
142	<	bool clauseComparator();
143	<	bool clauseChemObject();
144	<	bool clauseMolecule();
145	<	bool clauseMolName();
146	<	bool clauseMolIndex();
147	<	bool clauseName();
150	<	bool clauseIndex();
151	<	bool clauseStuntDoubleName();
152	<	bool clauseStuntDoubleIndex();
137	>	bool clauseOr();
138	>	bool clauseAnd();
139	>	bool clauseNot();
140	>	bool clausePrimitive();
141	>	bool clauseWithin();
142	>	bool clauseComparator();
143	>	bool clauseChemObjName();
144	>	bool clauseIndex();
145	>	Token tokenNext();
146	>	boost::any valuePeek();
147	>	int tokPeek();
148
149	<	bool compileError(const std::string& errorMessage) {
150	<	std::cerr << "SelectionCompiler Error: " << errorMessage <<  << std::endl;
151	<	error = true;
152	<	this.errorMessage = errorMessage;
153	<	return false;
154	<	}
149	>	bool addTokenToPostfix(const Token& token);
150	>	bool isNameValid(const std::string& name);
151	>
152	>	bool compileError(const std::string& errorMsg) {
153	>
154	>	sprintf( painCave.errMsg,
155	>	"SelectionCompiler Error: %s\n", errorMsg.c_str());
156	>	painCave.severity = OPENMD_ERROR;
157	>	painCave.isFatal = 1;
158	>	simError();
159	>
160	>	error = true;
161	>	this->errorMessage = errorMsg;
162	>	return false;
163	>	}
164
165	<	bool commandExpected() {
166	<	return compileError("command expected");
167	<	}
165	>	bool commandExpected() {
166	>	return compileError("command expected");
167	>	}
168
169	<	bool invalidExpressionToken(const std::string& ident) {
170	<	return compileError("invalid expression token:" + ident);
171	<	}
169	>	bool invalidExpressionToken(const std::string& ident) {
170	>	return compileError("invalid expression token:" + ident);
171	>	}
172
173	<	bool unrecognizedToken() {
174	<	return compileError("unrecognized token");
175	<	}
173	>	bool unrecognizedToken() {
174	>	return compileError("unrecognized token");
175	>	}
176
177	<	bool badArgumentCount() {
178	<	return compileError("bad argument count");
179	<	}
177	>	bool badArgumentCount() {
178	>	return compileError("bad argument count");
179	>	}
180
181	<	bool endOfExpressionExpected() {
182	<	return compileError("end of expression expected");
183	<	}
181	>	bool endOfExpressionExpected() {
182	>	return compileError("end of expression expected");
183	>	}
184
185	<	bool leftParenthesisExpected() {
186	<	return compileError("left parenthesis expected");
187	<	}
185	>	bool leftParenthesisExpected() {
186	>	return compileError("left parenthesis expected");
187	>	}
188
189	<	bool rightParenthesisExpected() {
190	<	return compileError("right parenthesis expected");
191	<	}
189	>	bool rightParenthesisExpected() {
190	>	return compileError("right parenthesis expected");
191	>	}
192
193	<	bool commaExpected() {
194	<	return compileError("comma expected");
195	<	}
193	>	bool commaExpected() {
194	>	return compileError("comma expected");
195	>	}
196
197	<	bool unrecognizedExpressionToken() {
198	<	return compileError("unrecognized expression token:" + valuePeek());
199	<	}
197	>	bool unrecognizedExpressionToken() {
198	>	boost::any tmp = valuePeek();
199	>	std::string tokenStr;
200
201	<	bool comparisonOperatorExpected() {
202	<	return compileError("comparison operator expected");
203	<	}
201	>	try {
202	>	tokenStr = boost::any_cast<std::string>(tmp);
203	>	} catch(const boost::bad_any_cast &) {
204	>	return compileError("any_cast error");
205	>	}
206	>
207	>	return compileError("unrecognized expression token:" + tokenStr);
208	>	}
209
210	<	bool integerExpected() {
211	<	return compileError("integer expected");
212	<	}
210	>	bool comparisonOperatorExpected() {
211	>	return compileError("comparison operator expected");
212	>	}
213	>
214	>	bool numberExpected() {
215	>	return compileError("number expected");
216	>	}
217
218	+	bool numberOrKeywordExpected() {
219	+	return compileError("number or keyword expected");
220	+	}
221
222	<	std::string filename;
223	<	std::string script;
222	>	std::string filename;
223	>	std::string script;
224
225	<	std::vector<int> lineNumbers;
226	<	std::vector<int> lineIndices;
227	<	std::vector<std::vector<Token> >aatokenCompiled;
225	>	std::vector<int> lineNumbers;
226	>	std::vector<int> lineIndices;
227	>	std::vector<std::vector<Token> >aatokenCompiled;
228
229	<	bool error;
230	<	std::string errorMessage;
231	<	std::string errorLine;
229	>	bool error;
230	>	std::string errorMessage;
231	>	std::string errorLine;
232
233	<	int cchScript;
234	<	short lineCurrent;
233	>	int cchScript;
234	>	short lineCurrent;
235
236	<	int ichToken;
237	<	int cchToken;
238	<	std::vector<Token> atokenCommand;
236	>	int ichToken;
237	>	int cchToken;
238	>	std::vector<Token> atokenCommand;
239
240	<	int ichCurrentCommand;
240	>	int ichCurrentCommand;
241
242	<	std::vector<Token> ltokenPostfix;
243	<	std::vector<Token> atokenInfix;
244	<	int itokenInfix;
242	>	std::vector<Token> ltokenPostfix;
243	>	std::vector<Token> atokenInfix;
244	>	int itokenInfix;
245
246	<	//std::vector<Token> compiledTokens_;
247	<	};
246	>	//std::vector<Token> compiledTokens_;
247	>	};
248
249		}
250		#endif

Comparing trunk/src/selection/SelectionCompiler.hpp (property svn:keywords):
Revision 278 by tim, Tue Feb 1 22:49:23 2005 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines