ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/selection/SelectionCompiler.hpp
(Generate patch)

Comparing trunk/src/selection/SelectionCompiler.hpp (file contents):
Revision 494 by tim, Wed Apr 13 22:43:43 2005 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 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
# Line 45 | Line 45
45   #include <string>
46   #include <vector>
47  
48 < #include "selection/Token.hpp"
48 > #include "selection/SelectionToken.hpp"
49   #include "selection/TokenMap.hpp"
50 < namespace oopse {
50 > #include "brains/SimInfo.hpp"
51  
52 + namespace OpenMD {
53  
53 – /**
54 – * @class SelectionCompiler SelectionCompiler.hpp "selection/SelectionCompiler.hpp"
55 – * @brief compile a selection script to tokens
56 – * @todo document
57 – * <pre>
54  
55 <    expression       :: = clauseOr
55 >  /**
56 >   * @class SelectionCompiler SelectionCompiler.hpp "selection/SelectionCompiler.hpp"
57 >   * @brief compile a selection script to tokens
58 >   * @todo document
59 >   * <pre>
60  
61 <    clauseOr         ::= clauseAnd {OR clauseAnd}*
61 >   expression       :: = clauseOr
62  
63 <    clauseAnd        ::= clauseNot {AND clauseNot}*
63 >   clauseOr         ::= clauseAnd {OR clauseAnd}*
64  
65 <    clauseNot        ::= NOT clauseNot | clausePrimitive
65 >   clauseAnd        ::= clauseNot {AND clauseNot}*
66  
67 <    clausePrimitive  ::= clauseComparator |
68 <                         clauseWithin |
69 <                         clauseName |
70 <                         none | all |
71 <                         ( clauseOr )
67 >   clauseNot        ::= NOT clauseNot | clausePrimitive
68  
69 <    clauseComparator ::= atomproperty comparatorop integer
69 >   clausePrimitive  ::= clauseComparator |
70 >   clauseWithin |
71 >   clauseName |
72 >   none | all |
73 >   ( clauseOr )
74  
75 <    clauseWithin     ::= WITHIN ( clauseDistance , expression )
75 >   clauseComparator ::= atomproperty comparatorop integer
76  
77 <    clauseDistance   ::= integer | decimal
77 >   clauseWithin     ::= WITHIN ( clauseDistance , expression )
78 >
79 >   clauseDistance   ::= integer | decimal
80          
81 <    clauseName::= *|string{.string{.string}}
81 >   clauseName::= *|string{.string{.string}}
82  
83  
84 < * </pre>
85 < */
86 < class SelectionCompiler{
87 <    public:
88 <        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 <            return strError;
112 <        }
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();
125 <        bool lookingAtDecimal(bool allowNegative);
126 <        bool lookingAtInteger(bool allowNegative);
127 <        bool lookingAtLookupToken();
128 <        bool lookingAtSpecialString();
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);        
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);        
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 clauseChemObjName();        
144 <        bool clauseIndex();
145 <        Token tokenNext();
146 <        boost::any valuePeek();
147 <        int tokPeek();
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 addTokenToPostfix(const Token& token);
150 <        bool isNameValid(const std::string& name);
149 >    bool addTokenToPostfix(const Token& token);
150 >    bool isNameValid(const std::string& name);
151  
152 <        bool compileError(const std::string& errorMsg) {
153 <            std::cerr << "SelectionCompiler Error: " << errorMsg << std::endl;
154 <            error = true;
155 <            this->errorMessage = errorMsg;
156 <            return false;
157 <        }
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 <            boost::any tmp = valuePeek();
199 <            std::string tokenStr;
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 <            }
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 <        }
207 >      return compileError("unrecognized expression token:" + tokenStr);
208 >    }
209  
210 <        bool comparisonOperatorExpected() {
211 <            return compileError("comparison operator expected");
212 <        }
210 >    bool comparisonOperatorExpected() {
211 >      return compileError("comparison operator expected");
212 >    }
213  
214 <        bool numberExpected() {
215 <            return compileError("number expected");
216 <        }        
214 >    bool numberExpected() {
215 >      return compileError("number expected");
216 >    }        
217          
218 <        bool numberOrKeywordExpected() {
219 <            return compileError("number or keyword expected");
220 <        }        
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

Diff Legend

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