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 277 by tim, Tue Feb 1 06:55:00 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	<
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	<	* <pre>
52	>	namespace OpenMD {
53
54	–	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 |
63	<	clauseWithin |
64	<	clauseResidueSpec |
65	<	none | all |
66	<	( 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
75	>	clauseComparator ::= atomproperty comparatorop integer
76
77	<
77	>	clauseWithin     ::= WITHIN ( clauseDistance , expression )
78
79	+	clauseDistance   ::= integer | decimal
80	+
81	+	clauseName::= *|string{.string{.string}}
82
77	–	clauseResidueSpec::= { clauseResNameSpec }
78	–	{ clauseResNumSpec }
79	–	{ chainSpec }
80	–	{ clauseAtomSpec }
81	–	{ modelSpec }
83
84	<	clauseResNameSpec::= * | [ resNamePattern ] | resNamePattern
84	>	* </pre>
85	>	*/
86	>	class SelectionCompiler{
87	>	public:
88	>	bool compile(const std::string& filename, const std::string& script );
89	>
90
91	<	// question marks are part of identifiers
92	<	// they get split up and dealt with as wildcards at runtime
93	<	// and the integers which are residue number chains get bundled
88	<	// in with the identifier and also split out at runtime
89	<	// iff a variable of that name does not exist
91	>	std::vector<int> getLineNumbers() {
92	>	return lineNumbers;
93	>	}
94
95	<	resNamePattern   ::= up to 3 alphanumeric chars with * and ?
95	>	std::vector<int> getLineIndices() {
96	>	return lineIndices;
97	>	}
98
99	<	clauseResNumSpec ::= * | clauseSequenceRange
99	>	std::vector<std::vector<Token> > getAatokenCompiled() {
100	>	return aatokenCompiled;
101	>	}
102
103	<	clauseSequenceRange ::= clauseSequenceCode { - clauseSequenceCode }
103	>	std::string getErrorMessage() {
104	>	std::string strError = errorMessage;
105	>	strError += " : " + errorLine + "\n";
106
107	<	clauseSequenceCode ::= seqcode | {-} integer
107	>	if (!filename.empty()) {
108	>	strError += filename;
109	>	}
110
111	<	clauseChainSpec  ::= {:} * | identifier | integer
111	>	return strError;
112	>	}
113
114	<	clauseAtomSpec   ::= . * | . identifier {*} // note that this * is *not* a wildcard
114	>
115	>	private:
116
117	<	clauseModelSpec  ::= {:|/} * | integer
104	<
105	<	* </pre>
106	<	*/
107	<	class SelectionCompiler{
108	<	public:
109	<	bool compile();
117	>	bool internalCompile();
118
111	–	std::vector<Token> getCompiledTokens();
112	–	private:
119
120	<	bool clauseOr();
121	<	bool clauseAnd();
122	<	bool clauseNot();
123	<	bool clausePrimitive();
124	<	bool clauseWithin();
125	<	bool clauseComparator();
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<Token>& ltoken);
134	>	bool compileExpression();
135	>	bool compileExpression(int itoken);
136
137	<	internalCompile();
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	<	std::vector<Token> compiledTokens_;
150	<	};
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	+	}
168	+
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	+	}
176	+
177	+	bool badArgumentCount() {
178	+	return compileError("bad argument count");
179	+	}
180	+
181	+	bool endOfExpressionExpected() {
182	+	return compileError("end of expression expected");
183	+	}
184	+
185	+	bool leftParenthesisExpected() {
186	+	return compileError("left parenthesis expected");
187	+	}
188	+
189	+	bool rightParenthesisExpected() {
190	+	return compileError("right parenthesis expected");
191	+	}
192	+
193	+	bool commaExpected() {
194	+	return compileError("comma expected");
195	+	}
196	+
197	+	bool unrecognizedExpressionToken() {
198	+	boost::any tmp = valuePeek();
199	+	std::string tokenStr;
200	+
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 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;
224	+
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;
232	+
233	+	int cchScript;
234	+	short lineCurrent;
235	+
236	+	int ichToken;
237	+	int cchToken;
238	+	std::vector<Token> atokenCommand;
239	+
240	+	int ichCurrentCommand;
241	+
242	+	std::vector<Token> ltokenPostfix;
243	+	std::vector<Token> atokenInfix;
244	+	int itokenInfix;
245	+
246	+	//std::vector<Token> compiledTokens_;
247	+	};
248	+
249		}
250		#endif
251	+

Comparing trunk/src/selection/SelectionCompiler.hpp (property svn:keywords):
Revision 277 by tim, Tue Feb 1 06:55:00 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