restore

firewave · firewave · commit 8a467bc5297a · 2024-12-22T15:20:19.000+01:00
diff --git a/lib/findtoken.h b/lib/findtoken.h
@@ -41,8 +41,8 @@ inline std::vector<MathLib::bigint> evaluateKnownValues(const Token* tok)
     return {tok->getKnownIntValue()};
 }
 
-template<class T, class Found, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-void findTokensImpl(T* start, const Token* end, const std::function<bool(const Token*)>& pred, Found found)
+template<class T, class Predicate, class Found, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+void findTokensImpl(T* start, const Token* end, const Predicate& pred, Found found)
 {
     for (T* tok = start; precedes(tok, end); tok = tok->next()) {
         if (pred(tok)) {
@@ -52,8 +52,8 @@ void findTokensImpl(T* start, const Token* end, const std::function<bool(const T
     }
 }
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-std::vector<T*> findTokens(T* start, const Token* end, const std::function<bool(const Token*)>& pred)
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokens(T* start, const Token* end, const Predicate& pred)
 {
     std::vector<T*> result;
     findTokensImpl(start, end, pred, [&](T* tok) {
@@ -63,8 +63,8 @@ std::vector<T*> findTokens(T* start, const Token* end, const std::function<bool(
     return result;
 }
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-T* findToken(T* start, const Token* end, const std::function<bool(const Token*)>& pred)
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+T* findToken(T* start, const Token* end, const Predicate& pred)
 {
     T* result = nullptr;
     findTokensImpl(start, end, pred, [&](T* tok) {
@@ -101,12 +101,12 @@ bool findTokensSkipDeadCodeImpl(const Library& library,
                                 const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate,
                                 bool skipUnevaluated);
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
 std::vector<T*> findTokensSkipDeadCode(const Library& library,
                                        T* start,
                                        const Token* end,
-                                       const std::function<bool(const Token*)>& pred,
-                                       const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate)
+                                       const Predicate& pred,
+                                       const Evaluate& evaluate)
 {
     std::vector<T*> result;
 
@@ -126,18 +126,18 @@ std::vector<T*> findTokensSkipDeadCode(const Library& library,
     return result;
 }
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-std::vector<T*> findTokensSkipDeadCode(const Library& library, T* start, const Token* end, const std::function<bool(const Token*)>& pred)
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokensSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred)
 {
     return findTokensSkipDeadCode(library, start, end, pred, &evaluateKnownValues);
 }
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
 std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library,
                                                      T* start,
                                                      const Token* end,
-                                                     const std::function<bool(const Token*)>& pred,
-                                                     const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate)
+                                                     const Predicate& pred,
+                                                     const Evaluate& evaluate)
 {
     std::vector<T*> result;
 
@@ -157,15 +157,15 @@ std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library,
     return result;
 }
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library, T* start, const Token* end, const std::function<bool(const Token*)>& pred)
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library, T* start, const Token* end, const Predicate& pred)
 {
     return findTokensSkipDeadAndUnevaluatedCode(library, start, end, pred, &evaluateKnownValues);
 }
 
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const std::function<bool(const Token*)>& pred, const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate)
+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred, const Evaluate& evaluate)
 {
     T* result = nullptr;
 
@@ -186,8 +186,8 @@ T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, con
     return result;
 }
 
-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
-T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const std::function<bool(const Token*)>& pred)
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred)
 {
     return findTokenSkipDeadCode(library, start, end, pred, &evaluateKnownValues);
 }

Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ inline std::vector<MathLib::bigint> evaluateKnownValues(const Token* tok)`
`41`	`41`	`return {tok->getKnownIntValue()};`
`42`	`42`	`}`
`43`	`43`
`44`		`-template<class T, class Found, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`45`		`-void findTokensImpl(T* start, const Token* end, const std::function<bool(const Token*)>& pred, Found found)`
	`44`	`+template<class T, class Predicate, class Found, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`45`	`+void findTokensImpl(T* start, const Token* end, const Predicate& pred, Found found)`
`46`	`46`	`{`
`47`	`47`	`for (T* tok = start; precedes(tok, end); tok = tok->next()) {`
`48`	`48`	`if (pred(tok)) {`
`@@ -52,8 +52,8 @@ void findTokensImpl(T* start, const Token* end, const std::function<bool(const T`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`56`		`-std::vector<T> findTokens(T start, const Token* end, const std::function<bool(const Token*)>& pred)`
	`55`	`+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`56`	`+std::vector<T> findTokens(T start, const Token* end, const Predicate& pred)`
`57`	`57`	`{`
`58`	`58`	`std::vector<T*> result;`
`59`	`59`	`findTokensImpl(start, end, pred, [&](T* tok) {`
`@@ -63,8 +63,8 @@ std::vector<T> findTokens(T start, const Token* end, const std::function<bool(`
`63`	`63`	`return result;`
`64`	`64`	`}`
`65`	`65`
`66`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`67`		`-T* findToken(T* start, const Token* end, const std::function<bool(const Token*)>& pred)`
	`66`	`+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`67`	`+T* findToken(T* start, const Token* end, const Predicate& pred)`
`68`	`68`	`{`
`69`	`69`	`T* result = nullptr;`
`70`	`70`	`findTokensImpl(start, end, pred, [&](T* tok) {`
`@@ -101,12 +101,12 @@ bool findTokensSkipDeadCodeImpl(const Library& library,`
`101`	`101`	`const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate,`
`102`	`102`	`bool skipUnevaluated);`
`103`	`103`
`104`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`104`	`+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`105`	`105`	`std::vector<T*> findTokensSkipDeadCode(const Library& library,`
`106`	`106`	`T* start,`
`107`	`107`	`const Token* end,`
`108`		`- const std::function<bool(const Token*)>& pred,`
`109`		`- const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate)`
	`108`	`+ const Predicate& pred,`
	`109`	`+ const Evaluate& evaluate)`
`110`	`110`	`{`
`111`	`111`	`std::vector<T*> result;`
`112`	`112`
`@@ -126,18 +126,18 @@ std::vector<T*> findTokensSkipDeadCode(const Library& library,`
`126`	`126`	`return result;`
`127`	`127`	`}`
`128`	`128`
`129`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`130`		`-std::vector<T> findTokensSkipDeadCode(const Library& library, T start, const Token* end, const std::function<bool(const Token*)>& pred)`
	`129`	`+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`130`	`+std::vector<T> findTokensSkipDeadCode(const Library& library, T start, const Token* end, const Predicate& pred)`
`131`	`131`	`{`
`132`	`132`	`return findTokensSkipDeadCode(library, start, end, pred, &evaluateKnownValues);`
`133`	`133`	`}`
`134`	`134`
`135`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`135`	`+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`136`	`136`	`std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library,`
`137`	`137`	`T* start,`
`138`	`138`	`const Token* end,`
`139`		`- const std::function<bool(const Token*)>& pred,`
`140`		`- const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate)`
	`139`	`+ const Predicate& pred,`
	`140`	`+ const Evaluate& evaluate)`
`141`	`141`	`{`
`142`	`142`	`std::vector<T*> result;`
`143`	`143`
`@@ -157,15 +157,15 @@ std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library,`
`157`	`157`	`return result;`
`158`	`158`	`}`
`159`	`159`
`160`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`161`		`-std::vector<T> findTokensSkipDeadAndUnevaluatedCode(const Library& library, T start, const Token* end, const std::function<bool(const Token*)>& pred)`
	`160`	`+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`161`	`+std::vector<T> findTokensSkipDeadAndUnevaluatedCode(const Library& library, T start, const Token* end, const Predicate& pred)`
`162`	`162`	`{`
`163`	`163`	`return findTokensSkipDeadAndUnevaluatedCode(library, start, end, pred, &evaluateKnownValues);`
`164`	`164`	`}`
`165`	`165`
`166`	`166`
`167`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`168`		`-T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const std::function<bool(const Token)>& pred, const std::function<std::vector<MathLib::bigint>(const Token)>& evaluate)`
	`167`	`+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`168`	`+T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred, const Evaluate& evaluate)`
`169`	`169`	`{`
`170`	`170`	`T* result = nullptr;`
`171`	`171`
`@@ -186,8 +186,8 @@ T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, con`
`186`	`186`	`return result;`
`187`	`187`	`}`
`188`	`188`
`189`		`-template<class T, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
`190`		`-T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const std::function<bool(const Token*)>& pred)`
	`189`	`+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T, const Token> )>`
	`190`	`+T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred)`
`191`	`191`	`{`
`192`	`192`	`return findTokenSkipDeadCode(library, start, end, pred, &evaluateKnownValues);`
`193`	`193`	`}`