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

Comparing trunk/src/selection/SelectionCompiler.cpp (file contents):
Revision 279 by tim, Wed Feb 2 12:51:25 2005 UTC vs.
Revision 283 by tim, Thu Feb 3 23:14:05 2005 UTC

# Line 40 | Line 40
40   */
41  
42   #include "selection/SelectionCompiler.hpp"
43 + #include "utils/StringUtils.hpp"
44   namespace oopse {
45  
46   bool SelectionCompiler::compile(const std::string& filename, const std::string& script) {
# Line 50 | Line 51 | bool SelectionCompiler::compile(const std::string& fil
51      lineIndices.clear();
52      aatokenCompiled.clear();
53          
54 <    if (internalcompile()) {
54 >    if (internalCompile()) {
55          return true;
56      }
57      
58      int icharEnd;
59 <    if ((icharEnd = script.find('\r', ichCurrentCommand)) == std::string:npos &&
60 <        (icharEnd = script.find('\n', ichCurrentCommand)) == std::string:npos) {
59 >    if ((icharEnd = script.find('\r', ichCurrentCommand)) == std::string::npos &&
60 >        (icharEnd = script.find('\n', ichCurrentCommand)) == std::string::npos) {
61          icharEnd = script.size();
62      }
63      errorLine = script.substr(ichCurrentCommand, icharEnd);
# Line 71 | Line 72 | bool SelectionCompiler::internalCompile(){
72  
73      error = false;
74  
75 <    std::vector<Token> lltoken;
75 >    //std::vector<Token> lltoken;
76 >    aatokenCompiled.clear();
77      std::vector<Token> ltoken;
78  
79 <    //Token tokenCommand = null;
80 <    int tokCommand = Token.nada;
79 >    Token tokenCommand;
80 >    int tokCommand = Token::nada;
81  
82      for ( ; true; ichToken += cchToken) {
83          if (lookingAtLeadingWhitespace())
84              continue;
85          if (lookingAtComment())
86              continue;
87 <        boolean endOfLine = lookingAtEndOfLine();
87 >        bool endOfLine = lookingAtEndOfLine();
88          if (endOfLine || lookingAtEndOfStatement()) {
89 <            if (tokCommand != Token.nada) {
89 >            if (tokCommand != Token::nada) {
90                  if (! compileCommand(ltoken)) {
91                      return false;
92                  }
93 <            lltoken.push_back(atokenCommand);
94 <            /** @todo*/
95 <            int iCommand = lltoken.size();
96 <            lineNumbers[iCommand] = lineCurrent;
97 <            lineIndices[iCommand] = (short) ichCurrentCommand;
96 <            ltoken.clear();
97 <            tokCommand = Token.nada;
93 >                aatokenCompiled.push_back(atokenCommand);
94 >                lineNumbers.push_back(lineCurrent);
95 >                lineIndices.push_back(ichCurrentCommand);
96 >                ltoken.clear();
97 >                tokCommand = Token::nada;
98              }
99              
100              if (ichToken < cchScript) {
# Line 105 | Line 105 | bool SelectionCompiler::internalCompile(){
105              break;
106          }
107  
108 <        if (tokCommand != Token.nada) {
108 >        if (tokCommand != Token::nada) {
109              if (lookingAtString()) {
110                  std::string str = getUnescapedStringLiteral();
111 <                ltoken.push_back(Token(Token.string, str));
111 >                ltoken.push_back(Token(Token::string, str));
112                  continue;
113              }
114 <            if ((tokCommand & Token.specialstring) != 0 &&
115 <                lookingAtSpecialString()) {
116 <                std::string str = script.substr(ichToken, ichToken + cchToken);
117 <                ltoken.push_back(Token(Token.string, str));
114 >            //if ((tokCommand & Token::specialstring) != 0 &&
115 >            //    lookingAtSpecialString()) {
116 >            //    std::string str = script.substr(ichToken, ichToken + cchToken);
117 >            //    ltoken.push_back(Token(Token::string, str));
118 >            //    continue;
119 >            //}
120 >            if (lookingAtDecimal((tokCommand & Token::negnums) != 0)) {
121 >                float value = lexi_cast<float>(script.substr(ichToken, ichToken + cchToken));          
122 >                ltoken.push_back(Token(Token::decimal, value));/**@todo*/
123                  continue;
124              }
125 <            if (lookingAtDecimal((tokCommand & Token.negnums) != 0)) {
121 <                float value = lexi_cast<float>((script.substr(ichToken, ichToken + cchToken));          
122 <                ltoken.push_back(Token(Token.decimal, new Float(value)));/**@todo*/
123 <                continue;
124 <            }
125 <            if (lookingAtInteger((tokCommand & Token.negnums) != 0)) {
125 >            if (lookingAtInteger((tokCommand & Token::negnums) != 0)) {
126                  std::string intString = script.substr(ichToken, ichToken + cchToken);
127                  int val = lexi_cast<int>(intString);
128 <                ltoken.push_back(new Token(Token.integer, val, intString));/**@todo*/
128 >                ltoken.push_back(Token(Token::integer, val, intString));/**@todo*/
129                  continue;
130              }
131          }
132        
133          if (lookingAtLookupToken()) {
134 <            std::string ident = script.subst(ichToken, ichToken + cchToken);
134 >            std::string ident = script.substr(ichToken, ichToken + cchToken);
135  
136 <            /**@todo */
137 <            Token token = (Token) Token.map.get(ident);
138 <            if (token == NULL) {
139 <
136 >            Token token;            
137 >            Token* pToken = TokenMap::getInstance()->getToken(ident);
138 >            if (pToken != NULL) {
139 >                token = *pToken;
140 >            } else {
141 >                token = Token(Token::identifier, ident);
142              }
141 –            Token token(Token.identifier, ident);
142 –
143              
144              int tok = token.tok;
145              
146              switch (tokCommand) {
147 <                case Token.nada:
147 >                case Token::nada:
148                      ichCurrentCommand = ichToken;
149                      //tokenCommand = token;
150                      tokCommand = tok;
151 <                    if ((tokCommand & Token.command) == 0)
151 >                    if ((tokCommand & Token::command) == 0)
152                      return commandExpected();
153                      break;
154  
155 <                case Token.define:
155 >                case Token::define:
156                      if (ltoken.size() == 1) {
157                          // we are looking at the variable name
158 <                        if (tok != Token.identifier &&
159 <                        (tok & Token.predefinedset) != Token.predefinedset)
158 >                        if (tok != Token::identifier &&
159 >                        (tok & Token::predefinedset) != Token::predefinedset)
160                          return invalidExpressionToken(ident);
161                      } else {
162                      // we are looking at the expression
163 <                    if (tok != Token.identifier && tok != Token.set &&
164 <                        (tok & (Token.expression | Token.predefinedset)) == 0)
163 >                    if (tok != Token::identifier &&
164 >                        (tok & (Token::expression | Token::predefinedset)) == 0)
165                          return invalidExpressionToken(ident);
166                      }
167                      
168                      break;
169  
170 <                case Token.select:
171 <                    if (tok != Token.identifier && (tok & Token.expression) == 0)
170 >                case Token::select:
171 >                    if (tok != Token::identifier && (tok & Token::expression) == 0)
172                          return invalidExpressionToken(ident);
173                  break;
174              }
# Line 183 | Line 183 | bool SelectionCompiler::internalCompile(){
183          return unrecognizedToken();
184      }
185  
186 –    aatokenCompiled.push_back(lltoken);
186      return true;
187    }
188  
# Line 236 | Line 235 | bool SelectionCompiler::internalCompile(){
235      int ichT = ichToken + 1;
236      //    while (ichT < cchScript && script.charAt(ichT++) != chFirst)
237      char ch;
238 <    boolean previousCharBackslash = false;
238 >    bool previousCharBackslash = false;
239      while (ichT < cchScript) {
240 <      ch = script.[ichT++];
240 >      ch = script[ichT++];
241        if (ch == '"' && !previousCharBackslash)
242          break;
243        previousCharBackslash = ch == '\\' ? !previousCharBackslash : false;
# Line 249 | Line 248 | std::string SelectionCompiler::getUnescapedStringLiter
248  
249    
250   std::string SelectionCompiler::getUnescapedStringLiteral() {
251 <    StringBuffer sb = new StringBuffer(cchToken - 2);
251 >    /** @todo */
252 >    std::string sb(cchToken - 2, ' ');
253 >    
254      int ichMax = ichToken + cchToken - 1;
255      int ich = ichToken + 1;
256  
# Line 292 | Line 293 | std::string SelectionCompiler::getUnescapedStringLiter
293                      }
294              }
295          }
296 <        sb.append(ch);
296 >        sb.append(1, ch);
297      }
298  
299 <    return "" + sb;
299 >    return sb;
300   }
301  
302 < static int SelectionCompiler::getHexitValue(char ch) {
302 > int SelectionCompiler::getHexitValue(char ch) {
303      if (ch >= '0' && ch <= '9')
304          return ch - '0';
305      else if (ch >= 'a' && ch <= 'f')
# Line 319 | Line 320 | bool SelectionCompiler::lookingAtSpecialString() {
320      return cchToken > 0;
321   }
322  
323 < bool SelectionCompiler::lookingAtDecimal(boolean allowNegative) {
323 > bool SelectionCompiler::lookingAtDecimal(bool allowNegative) {
324      if (ichToken == cchScript) {
325          return false;
326      }
# Line 328 | Line 329 | bool SelectionCompiler::lookingAtDecimal(boolean allow
329      if (script[ichT] == '-') {
330          ++ichT;
331      }
332 <    boolean digitSeen = false;
332 >    bool digitSeen = false;
333      char ch = 'X';
334      while (ichT < cchScript && std::isdigit(ch = script[ichT])) {
335          ++ichT;
# Line 354 | Line 355 | bool SelectionCompiler::lookingAtDecimal(boolean allow
355      return digitSeen;
356   }
357  
358 < bool SelectionCompiler::lookingAtInteger(boolean allowNegative) {
358 > bool SelectionCompiler::lookingAtInteger(bool allowNegative) {
359      if (ichToken == cchScript) {
360          return false;
361      }
# Line 430 | Line 431 | bool SelectionCompiler::lookingAtLookupToken() {
431      return true;
432   }
433  
434 < bool SelectionCompiler::compileCommand(Vector ltoken) {
435 <    /** todo */
435 <    Token tokenCommand = (Token)ltoken.firstElement();
434 > bool SelectionCompiler::compileCommand(const std::vector<Token>& ltoken) {
435 >    const Token& tokenCommand = ltoken[0];
436      int tokCommand = tokenCommand.tok;
437 <        
438 <    atokenCommand = new Token[ltoken.size()];
439 <    ltoken.copyInto(atokenCommand);
440 <    if ((tokCommand & Token.expressionCommand) != 0 && !compileExpression()) {
437 >
438 >    atokenCommand = ltoken;
439 >    if ((tokCommand & Token::expressionCommand) != 0 && !compileExpression()) {
440          return false;
441      }
442 +    
443      return true;
444   }
445  
# Line 447 | Line 447 | bool SelectionCompiler::compileExpression() {
447      /** todo */
448      int i = 1;
449      int tokCommand = atokenCommand[0].tok;
450 <    if (tokCommand == Token.define)
451 <      i = 2;
452 <    else if ((tokCommand & Token.embeddedExpression) != 0) {
453 <      // look for the open parenthesis
454 <      while (i < atokenCommand.length &&
455 <             atokenCommand[i].tok != Token.leftparen)
450 >    if (tokCommand == Token::define) {
451 >        i = 2;
452 >    } else if ((tokCommand & Token::embeddedExpression) != 0) {
453 >        // look for the open parenthesis
454 >        while (i < atokenCommand.size() &&
455 >         atokenCommand[i].tok != Token::leftparen)
456          ++i;
457      }
458 <    if (i >= atokenCommand.length)
459 <      return true;
458 >
459 >    if (i >= atokenCommand.size()) {
460 >        return true;
461 >    }
462      return compileExpression(i);
463    }
464  
465                    
466 < bool SelectionCompiler::addTokenToPostfix(Token token) {
466 > bool SelectionCompiler::addTokenToPostfix(const Token& token) {
467      ltokenPostfix.push_back(token);
468      return true;
469   }
470  
471   bool SelectionCompiler::compileExpression(int itoken) {
472 <    ltokenPostfix = new Vector();
473 <    for (int i = 0; i < itoken; ++i)
472 >    ltokenPostfix.clear();
473 >    for (int i = 0; i < itoken; ++i) {
474          addTokenToPostfix(atokenCommand[i]);
475 <
475 >    }
476 >    
477      atokenInfix = atokenCommand;
478      itokenInfix = itoken;
479  
480 <    addTokenToPostfix(Token.tokenExpressionBegin);
480 >    addTokenToPostfix(Token::tokenExpressionBegin);
481      if (!clauseOr()) {
482          return false;
483      }
484      
485 <    addTokenToPostfix(Token.tokenExpressionEnd);
486 <    if (itokenInfix != atokenInfix.length) {
485 >    addTokenToPostfix(Token::tokenExpressionEnd);
486 >    if (itokenInfix != atokenInfix.size()) {
487          return endOfExpressionExpected();
488      }
489  
# Line 489 | Line 492 | Token SelectionCompiler::tokenNext() {
492   }
493  
494   Token SelectionCompiler::tokenNext() {
495 < if (itokenInfix == atokenInfix.length)
496 < return null;
497 < return atokenInfix[itokenInfix++];
495 >    if (itokenInfix == atokenInfix.size()) {
496 >        return Token();
497 >    }
498 >    return atokenInfix[itokenInfix++];
499   }
500  
501 < Object SelectionCompiler::valuePeek() {
502 <    if (itokenInfix == atokenInfix.length) {
503 <        return null;
501 > boost::any SelectionCompiler::valuePeek() {
502 >    if (itokenInfix == atokenInfix.size()) {
503 >        return boost::any();
504      } else {
505          return atokenInfix[itokenInfix].value;
506      }
507   }
508  
509   int SelectionCompiler::tokPeek() {
510 <    if (itokenInfix == atokenInfix.length) {
510 >    if (itokenInfix == atokenInfix.size()) {
511          return 0;
512      }else {
513          return atokenInfix[itokenInfix].tok;
# Line 515 | Line 519 | bool SelectionCompiler::clauseOr() {
519          return false;
520      }
521      
522 <    while (tokPeek() == Token.opOr) {
522 >    while (tokPeek() == Token::opOr) {
523          Token tokenOr = tokenNext();
524          if (!clauseAnd()) {
525              return false;
# Line 530 | Line 534 | bool SelectionCompiler::clauseAnd() {
534          return false;
535      }
536  
537 <    while (tokPeek() == Token.opAnd) {
537 >    while (tokPeek() == Token::opAnd) {
538          Token tokenAnd = tokenNext();
539          if (!clauseNot()) {
540              return false;
# Line 541 | Line 545 | bool SelectionCompiler::clauseNot() {
545   }
546  
547   bool SelectionCompiler::clauseNot() {
548 <    if (tokPeek() == Token.opNot) {
548 >    if (tokPeek() == Token::opNot) {
549          Token tokenNot = tokenNext();
550          if (!clauseNot()) {
551              return false;
# Line 554 | Line 558 | bool SelectionCompiler::clausePrimitive() {
558   bool SelectionCompiler::clausePrimitive() {
559      int tok = tokPeek();
560      switch (tok) {
561 <        case Token.within:
561 >        case Token::within:
562              return clauseWithin();
563 <        case Token.hyphen: // selecting a negative residue spec
564 <        case Token.integer:
565 <        case Token.seqcode:
566 <        case Token.asterisk:
567 <        case Token.leftsquare:
564 <        case Token.identifier:
565 <        case Token.x:
566 <        case Token.y:
567 <        case Token.z:
568 <        case Token.colon:
569 <            return clauseResidueSpec();
563 >
564 >        case Token::asterisk:
565 >        case Token::identifier:
566 >            return clauseChemObjName();
567 >      
568          default:
569 <            if ((tok & Token.atomproperty) == Token.atomproperty) {
569 >            if ((tok & Token::atomproperty) == Token::atomproperty) {
570                  return clauseComparator();
571              }
572 <            if ((tok & Token.predefinedset) != Token.predefinedset) {
572 >            if ((tok & Token::predefinedset) != Token::predefinedset) {
573                  break;
574              }
575              // fall into the code and below and just add the token
576 <        case Token.all:
577 <        case Token.none:
576 >        case Token::all:
577 >        case Token::none:
578              return addTokenToPostfix(tokenNext());
579 <        case Token.leftparen:
579 >        case Token::leftparen:
580              tokenNext();
581              if (!clauseOr()) {
582                  return false;
583              }
584 <            if (tokenNext().tok != Token.rightparen) {
584 >            if (tokenNext().tok != Token::rightparen) {
585                  return rightParenthesisExpected();
586              }
587              return true;
# Line 594 | Line 592 | bool SelectionCompiler::clauseComparator() {
592   bool SelectionCompiler::clauseComparator() {
593      Token tokenAtomProperty = tokenNext();
594      Token tokenComparator = tokenNext();
595 <    if ((tokenComparator.tok & Token.comparator) == 0) {
595 >    if ((tokenComparator.tok & Token::comparator) == 0) {
596          return comparisonOperatorExpected();
597      }
598  
599      Token tokenValue = tokenNext();
600 <    if (tokenValue.tok != Token.integer) {
600 >    if (tokenValue.tok != Token::integer) {
601          return integerExpected();
602      }
603      int val = tokenValue.intValue;
# Line 607 | Line 605 | bool SelectionCompiler::clauseComparator() {
605      // int intValue is the tok of the property you are comparing
606      // the value against which you are comparing is stored as an Integer
607      // in the object value
608 <    return addTokenToPostfix(new Token(tokenComparator.tok,
609 <                       tokenAtomProperty.tok,
612 <                       new Integer(val)));
608 >    return addTokenToPostfix(Token(tokenComparator.tok,
609 >                       tokenAtomProperty.tok, boost::any(val)));
610   }
611  
612   bool SelectionCompiler::clauseWithin() {
613      tokenNext();                             // WITHIN
614 <    if (tokenNext().tok != Token.leftparen) {  // (
614 >    if (tokenNext().tok != Token::leftparen) {  // (
615          return leftParenthesisExpected();
616      }
617      
618 <    Object distance;
618 >    boost::any distance;
619      Token tokenDistance = tokenNext();       // distance
620      switch(tokenDistance.tok) {
621 <        case Token.integer:
622 <            distance = new Float((tokenDistance.intValue * 4) / 1000f);
621 >        case Token::integer:
622 >            distance = float(tokenDistance.intValue);
623              break;
624 <        case Token.decimal:
624 >        case Token::decimal:
625              distance = tokenDistance.value;
626              break;
627          default:
628              return numberOrKeywordExpected();
629      }
630  
631 <    if (tokenNext().tok != Token.opOr) {       // ,
631 >    if (tokenNext().tok != Token::opOr) {       // ,
632          return commaExpected();
633      }
634      
# Line 639 | Line 636 | bool SelectionCompiler::clauseWithin() {
636          return false;
637      }
638      
639 <    if (tokenNext().tok != Token.rightparen) { // )T
639 >    if (tokenNext().tok != Token::rightparen) { // )T
640          return rightParenthesisExpected();
641      }
642      
643 <    return addTokenToPostfix(new Token(Token.within, distance));
643 >    return addTokenToPostfix(Token(Token::within, distance));
644   }
645  
646 < bool SelectionCompiler:: clauseChemObject() {
647 < }
646 > bool SelectionCompiler::clauseChemObjName() {
647 >    std::string chemObjName;
648 >    int tok = tokPeek();
649 >    if (!clauseName(chemObjName)){
650 >        return false;
651 >    }
652  
652 – bool SelectionCompiler:: clauseMolecule() {
653 – }
653  
654 < bool SelectionCompiler:: clauseMolName() {
655 < }
654 >    tok = tokPeek();
655 >    //allow two dot at most
656 >    if (tok == Token::dot) {
657 >        if (!clauseName(chemObjName)) {
658 >            return false;
659 >        }
660 >        tok = tokPeek();
661 >        if (tok == Token::dot) {
662 >            if (!clauseName(chemObjName)) {
663 >                return false;
664 >            }
665 >        }        
666 >    }
667  
668 < bool SelectionCompiler:: clauseMolIndex() {
668 >    return addTokenToPostfix(Token(Token::name, chemObjName));
669   }
670  
671 < bool SelectionCompiler:: clauseName() {
662 < }
671 > bool SelectionCompiler:: clauseName(std::string& name) {
672  
673 < bool SelectionCompiler:: clauseIndex() {
665 < }
673 >    int tok = tokPeek();
674  
675 < bool SelectionCompiler:: clauseStuntDoubleName() {
676 < }
675 >    if (tok == Token::asterisk || tok == Token::identifier) {
676 >        name += boost::any_cast<std::string>(tokenNext().value);
677 >        
678 >        while(true){
679 >            tok = tokPeek();
680 >            switch (tok) {
681 >                case Token::asterisk :
682 >                    name += "*";
683 >                    tokenNext();
684 >                    break;
685 >                case Token::identifier :
686 >                    name += boost::any_cast<std::string>(tokenNext().value);
687 >                    break;
688 >                case Token::integer :
689 >                    name += toString(boost::any_cast<int>(tokenNext().value));
690 >                    break;
691 >                case Token::dot :
692 >                    return true;
693 >                default :
694 >                    return true;
695 >            }
696 >        }
697 >        
698 >    }else {
699 >        return false;
700 >    }
701  
670 – bool SelectionCompiler:: clauseStuntDoubleIndex() {
702   }
703  
704 +
705   }

Diff Legend

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