bump simplecpp to 1.3.1

Author: danmar

externals/simplecpp/simplecpp.cpp

@@ -947,7 +947,7 @@ void simplecpp::TokenList::constFold()
         constFoldQuestionOp(&tok);
 
         // If there is no '(' we are done with the constant folding
-        if (tok->op != '(')
+        if (!tok || tok->op != '(')
             break;
 
         if (!tok->next || !tok->next->next || tok->next->next->op != ')')
@@ -1157,10 +1157,7 @@ void simplecpp::TokenList::constFoldMulDivRem(Token *tok)
         } else
             continue;
 
-        tok = tok->previous;
-        tok->setstr(toString(result));
-        deleteToken(tok->next);
-        deleteToken(tok->next);
+        simpleSquash(tok, toString(result));
     }
 }
 
@@ -1180,10 +1177,7 @@ void simplecpp::TokenList::constFoldAddSub(Token *tok)
         else
             continue;
 
-        tok = tok->previous;
-        tok->setstr(toString(result));
-        deleteToken(tok->next);
-        deleteToken(tok->next);
+        simpleSquash(tok, toString(result));
     }
 }
 
@@ -1203,10 +1197,7 @@ void simplecpp::TokenList::constFoldShift(Token *tok)
         else
             continue;
 
-        tok = tok->previous;
-        tok->setstr(toString(result));
-        deleteToken(tok->next);
-        deleteToken(tok->next);
+        simpleSquash(tok, toString(result));
     }
 }
 
@@ -1240,10 +1231,7 @@ void simplecpp::TokenList::constFoldComparison(Token *tok)
         else
             continue;
 
-        tok = tok->previous;
-        tok->setstr(toString(result));
-        deleteToken(tok->next);
-        deleteToken(tok->next);
+        simpleSquash(tok, toString(result));
     }
 }
 
@@ -1275,12 +1263,51 @@ void simplecpp::TokenList::constFoldBitwise(Token *tok)
                 result = (stringToLL(tok->previous->str()) ^ stringToLL(tok->next->str()));
             else /*if (*op == '|')*/
                 result = (stringToLL(tok->previous->str()) | stringToLL(tok->next->str()));
-            tok = tok->previous;
-            tok->setstr(toString(result));
-            deleteToken(tok->next);
-            deleteToken(tok->next);
+            simpleSquash(tok, toString(result));
+        }
+    }
+}
+
+void simplecpp::TokenList::simpleSquash(Token *&tok, const std::string & result)
+{
+    tok = tok->previous;
+    tok->setstr(result);
+    deleteToken(tok->next);
+    deleteToken(tok->next);
+}
+
+void simplecpp::TokenList::squashTokens(Token *&tok, const std::set<std::string> & breakPoints, bool forwardDirection, const std::string & result)
+{
+    const char * const brackets = forwardDirection ? "()" : ")(";
+    Token* Token::* const step = forwardDirection ? &Token::next : &Token::previous;
+    int skip = 0;
+    const Token * const tok1 = tok->*step;
+    while (tok1 && tok1->*step) {
+        if ((tok1->*step)->op == brackets[1]){
+            if (skip) {
+                --skip;
+                deleteToken(tok1->*step);
+            } else
+                break;
+        } else if ((tok1->*step)->op == brackets[0]) {
+            ++skip;
+            deleteToken(tok1->*step);
+        } else if (skip) {
+            deleteToken(tok1->*step);
+        } else if (breakPoints.count((tok1->*step)->str()) != 0) {
+            break;
+        } else {
+            deleteToken(tok1->*step);
         }
     }
+    simpleSquash(tok, result);
+}
+
+static simplecpp::Token * constFoldGetOperand(simplecpp::Token * tok, bool forwardDirection)
+{
+    simplecpp::Token* simplecpp::Token::* const step = forwardDirection ? &simplecpp::Token::next : &simplecpp::Token::previous;
+    const char bracket = forwardDirection ? ')' : '(';
+    return tok->*step && (tok->*step)->number && (!((tok->*step)->*step) ||  (((tok->*step)->*step)->op == bracket)) ? tok->*step : nullptr;
 }
 
 static const std::string AND("and");
@@ -1296,21 +1323,24 @@ void simplecpp::TokenList::constFoldLogicalOp(Token *tok)
         }
         if (tok->str() != "&&" && tok->str() != "||")
             continue;
-        if (!tok->previous || !tok->previous->number)
-            continue;
-        if (!tok->next || !tok->next->number)
+        const Token* const lhs = constFoldGetOperand(tok, false);
+        const Token* const rhs = constFoldGetOperand(tok, true);
+        if (!lhs) // if lhs is not a single number we don't need to fold
             continue;
 
-        int result;
-        if (tok->str() == "||")
-            result = (stringToLL(tok->previous->str()) || stringToLL(tok->next->str()));
-        else /*if (tok->str() == "&&")*/
-            result = (stringToLL(tok->previous->str()) && stringToLL(tok->next->str()));
-
-        tok = tok->previous;
-        tok->setstr(toString(result));
-        deleteToken(tok->next);
-        deleteToken(tok->next);
+        std::set<std::string> breakPoints;
+        breakPoints.insert(":");
+        breakPoints.insert("?");
+        if (tok->str() == "||"){
+            if (stringToLL(lhs->str()) != 0LL || (rhs && stringToLL(rhs->str()) != 0LL))
+                squashTokens(tok, breakPoints, stringToLL(lhs->str()) != 0LL, toString(1));
+        } else /*if (tok->str() == "&&")*/ {
+            breakPoints.insert("||");
+            if (stringToLL(lhs->str()) == 0LL || (rhs && stringToLL(rhs->str()) == 0LL))
+                squashTokens(tok, breakPoints, stringToLL(lhs->str()) == 0LL, toString(0));
+            else if (rhs && stringToLL(lhs->str()) && stringToLL(rhs->str()))
+                simpleSquash(tok, "1");
+        }
     }
 }
 
@@ -2088,7 +2118,7 @@ namespace simplecpp {
                         if (expandArg(&temp, defToken, parametertokens))
                             macroName = temp.cback()->str();
                         if (expandArg(&temp, defToken->next->next->next, parametertokens))
-                            macroName += temp.cback()->str();
+                            macroName += temp.cback() ? temp.cback()->str() : "";
                         else
                             macroName += defToken->next->next->next->str();
                         lastToken = defToken->next->next->next;
@@ -2132,7 +2162,8 @@ namespace simplecpp {
             for (const Token *partok = parametertokens[argnr]->next; partok != parametertokens[argnr + 1U];) {
                 const MacroMap::const_iterator it = macros.find(partok->str());
                 if (it != macros.end() && !partok->isExpandedFrom(&it->second) && (partok->str() == name() || expandedmacros.find(partok->str()) == expandedmacros.end())) {
-                    const std::set<TokenString> expandedmacros2; // temporary amnesia to allow reexpansion of currently expanding macros during argument evaluation
+                    std::set<TokenString> expandedmacros2(expandedmacros); // temporary amnesia to allow reexpansion of currently expanding macros during argument evaluation
+                    expandedmacros2.erase(name());
                     partok = it->second.expand(output, loc, partok, macros, expandedmacros2);
                 } else {
                     output->push_back(newMacroToken(partok->str(), loc, isReplaced(expandedmacros), partok));

externals/simplecpp/simplecpp.h

@@ -301,6 +301,8 @@ namespace simplecpp {
         void constFoldLogicalOp(Token *tok);
         void constFoldQuestionOp(Token **tok1);
 
+        void simpleSquash(Token *&tok, const std::string & result);
+        void squashTokens(Token *&tok, const std::set<std::string> & breakPoints, bool forwardDirection, const std::string & result);
         std::string readUntil(Stream &stream, const Location &location, char start, char end, OutputList *outputList);
         void lineDirective(unsigned int fileIndex, unsigned int line, Location *location);