diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
index 228c63c79..30b63ba39 100644
--- a/lib/checkbufferoverrun.cpp
+++ b/lib/checkbufferoverrun.cpp
@@ -596,44 +596,20 @@ void CheckBufferOverrun::checkFunctionParameter(const Token &tok, unsigned int p
     // Calling a user function?
     // only 1-dimensional arrays can be checked currently
     else if (arrayInfo.num().size() == 1) {
-        const Token *ftok = _tokenizer->getFunctionTokenByName(tok.str().c_str());
-        if (Token::Match(ftok, "%var% (") && Token::Match(ftok->next()->link(), ") const| {")) {
-            // Get varid for the corresponding parameter..
-            const Token *ftok2 = ftok->tokAt(2);
-            for (unsigned int i = 1; i < par; i++)
-                ftok2 = ftok2->nextArgument();
-            unsigned int parameterVarId = 0;
-            for (; ftok2; ftok2 = ftok2->next()) {
-                if (ftok2->str() == "(")
-                    ftok2 = ftok2->link();
-                else if (ftok2->str() == "," || ftok2->str() == ")")
-                    break;
-                else if (Token::Match(ftok2, "%var% ,|)|[")) {
-                    // check type..
-                    const Token *type = ftok2->previous();
-                    while (Token::Match(type, "*|const"))
-                        type = type->previous();
-                    if (type && _tokenizer->sizeOfType(type) == arrayInfo.element_size())
-                        parameterVarId = ftok2->varId();
-                }
-            }
+        const Function* func = _tokenizer->getSymbolDatabase()->findFunctionByName(tok.str(), tok.scope());;
+        if (func && func->hasBody) {
+            // Get corresponding parameter..
+            const Variable* parameter = func->getArgumentVar(par-1);
 
-            // No parameterVarId => bail out
-            if (parameterVarId == 0)
+            // Ensure that it has a compatible size..
+            if (!parameter || _tokenizer->sizeOfType(parameter->typeStartToken()) != arrayInfo.element_size())
                 return;
 
-            // Step into the function scope..
-            ftok = ftok->next()->link();
-            if (!Token::Match(ftok, ") const| {"))
-                return;
-            ftok = Token::findsimplematch(ftok, "{");
-            ftok = ftok->next();
-
             // Check the parameter usage in the function scope..
-            for (; ftok; ftok = ftok->next()) {
+            for (const Token* ftok = func->functionScope->classStart; ftok != func->functionScope->classEnd; ftok = ftok->next()) {
                 if (Token::Match(ftok, "if|for|while (")) {
                     // bailout if there is buffer usage..
-                    if (bailoutIfSwitch(ftok, parameterVarId)) {
+                    if (bailoutIfSwitch(ftok, parameter->varId())) {
                         break;
                     }
 
@@ -652,7 +628,7 @@ void CheckBufferOverrun::checkFunctionParameter(const Token &tok, unsigned int p
                 if (ftok->str() == "}")
                     break;
 
-                if (ftok->varId() == parameterVarId) {
+                if (ftok->varId() == parameter->varId()) {
                     if (Token::Match(ftok->previous(), "-- %var%") ||
                         Token::Match(ftok, "%var% --"))
                         break;
@@ -674,7 +650,7 @@ void CheckBufferOverrun::checkFunctionParameter(const Token &tok, unsigned int p
                 // Calling function..
                 if (Token::Match(ftok, "%var% (")) {
                     ArrayInfo ai(arrayInfo);
-                    ai.varid(parameterVarId);
+                    ai.varid(parameter->varId());
                     checkFunctionCall(ftok, ai, callstack);
                 }
             }
diff --git a/lib/checkmemoryleak.cpp b/lib/checkmemoryleak.cpp
index 937a58ade..742e6a786 100644
--- a/lib/checkmemoryleak.cpp
+++ b/lib/checkmemoryleak.cpp
@@ -119,7 +119,7 @@ bool CheckMemoryLeak::isclass(const Tokenizer *_tokenizer, const Token *tok, uns
 }
 //---------------------------------------------------------------------------
 
-CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2, unsigned int varid, std::list<const Token *> *callstack) const
+CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2, unsigned int varid, std::list<const Function*> *callstack) const
 {
     // What we may have...
     //     * var = (char *)malloc(10);
@@ -208,20 +208,20 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2,
     }
 
     // User function
-    const Token *ftok = tokenizer->getFunctionTokenByName(tok2->str().c_str());
-    if (ftok == NULL)
+    const Function* func = tokenizer->getSymbolDatabase()->findFunctionByName(tok2->str(), tok2->scope());
+    if (func == NULL)
         return No;
 
     // Prevent recursion
-    if (callstack && std::find(callstack->begin(), callstack->end(), ftok) != callstack->end())
+    if (callstack && std::find(callstack->begin(), callstack->end(), func) != callstack->end())
         return No;
 
-    std::list<const Token *> cs;
+    std::list<const Function*> cs;
     if (!callstack)
         callstack = &cs;
 
-    callstack->push_back(ftok);
-    return functionReturnType(ftok, callstack);
+    callstack->push_back(func);
+    return functionReturnType(func, callstack);
 }
 
 
@@ -408,35 +408,15 @@ void CheckMemoryLeak::mismatchAllocDealloc(const std::list<const Token *> &calls
     reportErr(callstack, Severity::error, "mismatchAllocDealloc", "Mismatching allocation and deallocation: " + varname);
 }
 
-CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Token *tok, std::list<const Token *> *callstack) const
+CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Function* func, std::list<const Function*> *callstack) const
 {
-    if (!tok)
+    if (!func || !func->hasBody)
         return No;
 
-    // Locate start of function
-    while (tok) {
-        if (tok->str() == "{" || tok->str() == "}")
-            return No;
-
-        if (tok->str() == "(") {
-            tok = tok->link();
-            break;
-        }
-
-        tok = tok->next();
-    }
-
-    // Is this the start of a function?
-    if (!Token::Match(tok, ") const| {"))
-        return No;
-
-    while (tok->str() != "{")
-        tok = tok->next();
-
     // Get return pointer..
     unsigned int varid = 0;
     unsigned int indentlevel = 0;
-    for (const Token *tok2 = tok; tok2; tok2 = tok2->next()) {
+    for (const Token *tok2 = func->functionScope->classStart; tok2 != func->functionScope->classEnd; tok2 = tok2->next()) {
         if (tok2->str() == "{")
             ++indentlevel;
         else if (tok2->str() == "}") {
@@ -471,7 +451,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Token *tok,
 
     // Check if return pointer is allocated..
     AllocType allocType = No;
-    while (NULL != (tok = tok->next())) {
+    for (const Token* tok = func->functionScope->classStart; tok != func->functionScope->classEnd; tok = tok->next()) {
         if (Token::Match(tok, "%varid% =", varid)) {
             allocType = getAllocationType(tok->tokAt(2), varid, callstack);
         }
@@ -656,20 +636,18 @@ const char * CheckMemoryLeakInFunction::call_func(const Token *tok, std::list<co
 
     // lock/unlock..
     if (varid == 0) {
-        const Token *ftok = _tokenizer->getFunctionTokenByName(funcname.c_str());
-        while (ftok && (ftok->str() != "{"))
-            ftok = ftok->next();
-        if (!ftok)
+        const Function* func = _tokenizer->getSymbolDatabase()->findFunctionByName(funcname, tok->scope());;
+        if (!func || !func->hasBody)
             return 0;
 
-        Token *func = getcode(ftok->next(), callstack, 0, alloctype, dealloctype, false, 1);
-        simplifycode(func);
+        Token *ftok = getcode(func->functionScope->classStart->next(), callstack, 0, alloctype, dealloctype, false, 1);
+        simplifycode(ftok);
         const char *ret = 0;
-        if (Token::simpleMatch(func, "; alloc ; }"))
+        if (Token::simpleMatch(ftok, "; alloc ; }"))
             ret = "alloc";
-        else if (Token::simpleMatch(func, "; dealloc ; }"))
+        else if (Token::simpleMatch(ftok, "; dealloc ; }"))
             ret = "dealloc";
-        TokenList::deleteTokens(func);
+        TokenList::deleteTokens(ftok);
         return ret;
     }
 
@@ -702,16 +680,12 @@ const char * CheckMemoryLeakInFunction::call_func(const Token *tok, std::list<co
             if (dot)
                 return "use";
 
-            const Token *ftok = _tokenizer->getFunctionTokenByName(funcname.c_str());
-            if (!ftok)
+            const Function* function = _tokenizer->getSymbolDatabase()->findFunctionByName(funcname, tok->scope());;
+            if (!function)
                 return "use";
 
             // how many parameters does the function want?
-            if (numpar != countParameters(ftok))
-                return "recursive";
-
-            const Function* function = _tokenizer->getSymbolDatabase()->findFunctionByToken(ftok);
-            if (!function)
+            if (numpar != function->argCount()) // TODO: Handle default parameters
                 return "recursive";
 
             const Variable* param = function->getArgumentVar(par-1);
@@ -738,10 +712,9 @@ const char * CheckMemoryLeakInFunction::call_func(const Token *tok, std::list<co
             return ret;
         }
         if (varid > 0 && Token::Match(tok, "& %varid% [,()]", varid)) {
-            const Token *ftok = _tokenizer->getFunctionTokenByName(funcname.c_str());
-            if (ftok == 0)
+            const Function *func = _tokenizer->getSymbolDatabase()->findFunctionByName(funcname, tok->scope());;
+            if (func == 0)
                 continue;
-            const Function* func = _tokenizer->getSymbolDatabase()->findFunctionByToken(ftok);
             AllocType a;
             const char *ret = functionArgAlloc(func, par, a);
 
diff --git a/lib/checkmemoryleak.h b/lib/checkmemoryleak.h
index 022459aea..6ff276957 100644
--- a/lib/checkmemoryleak.h
+++ b/lib/checkmemoryleak.h
@@ -116,7 +116,7 @@ public:
     /**
      * @brief Get type of allocation at given position
      */
-    AllocType getAllocationType(const Token *tok2, unsigned int varid, std::list<const Token *> *callstack = NULL) const;
+    AllocType getAllocationType(const Token *tok2, unsigned int varid, std::list<const Function*> *callstack = NULL) const;
 
     /**
      * @brief Get type of reallocation at given position
@@ -158,7 +158,7 @@ public:
     void memleakUponReallocFailureError(const Token *tok, const std::string &varname) const;
 
     /** What type of allocated memory does the given function return? */
-    AllocType functionReturnType(const Token *tok, std::list<const Token *> *callstack = NULL) const;
+    AllocType functionReturnType(const Function* func, std::list<const Function*> *callstack = NULL) const;
 
     /** Function allocates pointed-to argument (a la asprintf)? */
     const char *functionArgAlloc(const Function *func, unsigned int targetpar, AllocType &allocType) const;
diff --git a/lib/checknullpointer.cpp b/lib/checknullpointer.cpp
index 62e594fda..48422adbd 100644
--- a/lib/checknullpointer.cpp
+++ b/lib/checknullpointer.cpp
@@ -380,8 +380,7 @@ bool CheckNullPointer::CanFunctionAssignPointer(const Token *functiontoken, unsi
     int argumentNumber = 0;
     for (const Token *arg = functiontoken->tokAt(2); arg; arg = arg->nextArgument()) {
         if (Token::Match(arg, "%varid% [,)]", varid)) {
-            const Token *ftok = _tokenizer->getFunctionTokenByName(functiontoken->str().c_str());
-            const Function* func = _tokenizer->getSymbolDatabase()->findFunctionByToken(ftok);
+            const Function* func = _tokenizer->getSymbolDatabase()->findFunctionByName(functiontoken->str(), functiontoken->scope());
             if (!func) { // Unknown function
                 unknown = true;
                 return true; // assume that the function might assign the pointer
diff --git a/lib/checkother.cpp b/lib/checkother.cpp
index b85bbc965..5c1f78d8b 100644
--- a/lib/checkother.cpp
+++ b/lib/checkother.cpp
@@ -713,7 +713,7 @@ void CheckOther::checkRedundantAssignment()
                         }
                     }
                 } else if (scope->type == Scope::eSwitch) { // Avoid false positives if noreturn function is called in switch
-                    const Function* func = symbolDatabase->findFunctionByToken(_tokenizer->getFunctionTokenByName(tok->str().c_str()));
+                    const Function* func = symbolDatabase->findFunctionByName(tok->str(), tok->scope());;
                     if (!func || !func->hasBody) {
                         varAssignments.clear();
                         memAssignments.clear();
@@ -3306,8 +3306,8 @@ void CheckOther::checkRedundantCopy()
         const Token *match_end = (tok->next()->link()!=NULL)?tok->next()->link()->next():NULL;
         if (match_end==NULL || !Token::Match(match_end,expect_end_token)) //avoid usage like "const A a = getA()+3"
             break;
-        const Token *fToken = _tokenizer->getFunctionTokenByName(tok->str().c_str());
-        if (fToken &&fToken->previous() && fToken->previous()->str() == "&") {
+        const Function* func = _tokenizer->getSymbolDatabase()->findFunctionByName(tok->str(), tok->scope());;
+        if (func && func->tokenDef->previous() && func->tokenDef->previous()->str() == "&") {
             redundantCopyError(var_tok,var_tok->str());
         }
     }
diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp
index 6aa3239d8..b49d71c46 100644
--- a/lib/checkstl.cpp
+++ b/lib/checkstl.cpp
@@ -1156,8 +1156,7 @@ void CheckStl::string_c_str()
                            Token::simpleMatch(tok->linkAt(4), ") . c_str ( ) ;")) {
                     string_c_strError(tok);
                 } else if (Token::Match(tok, "return %var% (") && Token::simpleMatch(tok->linkAt(2), ") . c_str ( ) ;")) {
-                    const Token* fTok = _tokenizer->getFunctionTokenByName(tok->strAt(1).c_str());
-                    const Function* func = symbolDatabase->findFunctionByToken(fTok);
+                    const Function* func =_tokenizer->getSymbolDatabase()->findFunctionByName(tok->strAt(1), tok->scope());;
                     if (func && Token::simpleMatch(func->tokenDef->tokAt(-3), "std :: string"))
                         string_c_strError(tok);
                 } else if (Token::simpleMatch(tok, "return (") &&
diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
index 721626922..0ef0c958b 100644
--- a/lib/symboldatabase.cpp
+++ b/lib/symboldatabase.cpp
@@ -480,7 +480,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
                         continue;
                     }
                 }
-            } else if (scope->type == Scope::eFunction || scope->isLocal()) {
+            } else if (scope->isExecutable()) {
                 if (Token::simpleMatch(tok, "if (") &&
                     Token::simpleMatch(tok->next()->link(), ") {")) {
                     const Token *tok1 = tok->next()->link()->next();
@@ -2124,6 +2124,25 @@ const Function *SymbolDatabase::findFunctionByToken(const Token *tok) const
     return 0;
 }
 
+const Function* SymbolDatabase::findFunctionByName(const std::string& str, const Scope* startScope) const
+{
+    const Scope* currScope = startScope;
+    while (currScope && currScope->isExecutable()) {
+        if (currScope->functionOf)
+            currScope = currScope->functionOf;
+        else
+            currScope = currScope->nestedIn;
+    }
+    while (currScope) {
+        for (std::list<Function>::const_iterator i = currScope->functionList.begin(); i != currScope->functionList.end(); ++i) {
+            if (i->tokenDef->str() == str)
+                return &*i;
+        }
+        currScope = currScope->nestedIn;
+    }
+    return 0;
+}
+
 //---------------------------------------------------------------------------
 
 const Scope* SymbolDatabase::findScopeByName(const std::string& name) const
diff --git a/lib/symboldatabase.h b/lib/symboldatabase.h
index 6518465a0..7bb6224a1 100644
--- a/lib/symboldatabase.h
+++ b/lib/symboldatabase.h
@@ -572,6 +572,8 @@ public:
 
     const Function *findFunctionByToken(const Token *tok) const;
 
+    const Function* findFunctionByName(const std::string& str, const Scope* startScope) const;
+
     const Scope* findScopeByName(const std::string& name) const;
 
     bool isClassOrStruct(const std::string &type) const {
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 260445b3e..3ab273575 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -7507,19 +7507,6 @@ bool Tokenizer::IsScopeNoReturn(const Token *endScopeToken, bool *unknown)
 
 //---------------------------------------------------------------------------
 
-const Token *Tokenizer::getFunctionTokenByName(const char funcname[]) const
-{
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = _symbolDatabase->scopeList.begin(); scope != _symbolDatabase->scopeList.end(); ++scope) {
-        if (scope->type == Scope::eFunction) {
-            if (scope->classDef->str() == funcname)
-                return scope->classDef;
-        }
-    }
-    return NULL;
-}
-
 bool Tokenizer::isFunctionParameterPassedByValue(const Token *fpar) const
 {
     // TODO: If symbol database is available, use it.
diff --git a/lib/tokenize.h b/lib/tokenize.h
index 314a1a2ec..6df8a7b7f 100644
--- a/lib/tokenize.h
+++ b/lib/tokenize.h
@@ -142,14 +142,6 @@ public:
      */
     unsigned int sizeOfType(const Token *type) const;
 
-    /**
-     * Get function token by function name
-     * @todo better handling of overloaded functions
-     * @todo only scan parent scopes
-     * @param funcname function name
-     */
-    const Token *getFunctionTokenByName(const char funcname[]) const;
-
     /**
      * Try to determine if function parameter is passed by value by looking
      * at the function declaration.
diff --git a/test/testmemleak.cpp b/test/testmemleak.cpp
index 8020b7b56..c2b54c8e0 100644
--- a/test/testmemleak.cpp
+++ b/test/testmemleak.cpp
@@ -21,7 +21,7 @@
 #include "tokenize.h"
 #include "checkmemoryleak.h"
 #include "testsuite.h"
-
+#include "symboldatabase.h"
 #include <sstream>
 
 extern std::ostringstream errout;
@@ -49,7 +49,7 @@ private:
         std::istringstream istr(code);
         tokenizer.tokenize(istr, "test.cpp");
 
-        return ((const CheckMemoryLeak *)0)->functionReturnType(tokenizer.tokens());
+        return ((const CheckMemoryLeak *)0)->functionReturnType(&tokenizer.getSymbolDatabase()->scopeList.front().functionList.front());
     }
 
     void testFunctionReturnType() {
@@ -2421,7 +2421,7 @@ private:
 
         check("void foo(char **str)\n"
               "{\n"
-              "   char *a = malloc(20)\n"
+              "   char *a = malloc(20);\n"
               "   *str = a;\n"
               "}\n"
               "\n"
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index 4ef9b04aa..6777f66af 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -501,7 +501,7 @@ private:
         GET_SYMBOL_DB("void func() { }\n")
 
         // 2 scopes: Global and Function
-        ASSERT(db && db->scopeList.size() == 2 && tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 2);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->next());
@@ -509,7 +509,7 @@ private:
             ASSERT(scope && scope->className == "func");
             ASSERT(scope && scope->functionOf == 0);
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->next());
+            const Function *function = db->findFunctionByName("func", &db->scopeList.front());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->next());
@@ -522,7 +522,7 @@ private:
         GET_SYMBOL_DB("class Fred { void func() { } };\n")
 
         // 3 scopes: Global, Class, and Function
-        ASSERT(db && db->scopeList.size() == 3 && tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 3);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->tokAt(4));
@@ -530,7 +530,7 @@ private:
             ASSERT(scope && scope->className == "func");
             ASSERT(scope && scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->tokAt(4));
+            const Function *function = db->findFunctionByName("func", &db->scopeList.back());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->tokAt(4));
@@ -543,14 +543,14 @@ private:
         GET_SYMBOL_DB("class Fred { void func(); };\n")
 
         // 2 scopes: Global and Class (no Function scope because there is no function implementation)
-        ASSERT(db && db->scopeList.size() == 2 && !tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 2);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->tokAt(4));
 
             ASSERT(scope == NULL);
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->tokAt(4));
+            const Function *function = db->findFunctionByName("func", &db->scopeList.back());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->tokAt(4));
@@ -562,7 +562,7 @@ private:
         GET_SYMBOL_DB("class Fred { void func(); }; Fred::func() { }\n")
 
         // 3 scopes: Global, Class, and Function
-        ASSERT(db && db->scopeList.size() == 3 && tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 3);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->tokAt(12));
@@ -570,7 +570,7 @@ private:
             ASSERT(scope && scope->className == "func");
             ASSERT(scope && scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->tokAt(12));
+            const Function *function = db->findFunctionByName("func", &db->scopeList.back());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->tokAt(12));
@@ -583,14 +583,14 @@ private:
         GET_SYMBOL_DB("void (*func(int f))(char) { }\n")
 
         // 2 scopes: Global and Function
-        ASSERT(db && db->scopeList.size() == 2 && tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 2);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->tokAt(3));
 
             ASSERT(scope && scope->className == "func");
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->tokAt(3));
+            const Function *function = db->findFunctionByName("func", &db->scopeList.front());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->tokAt(3));
@@ -602,14 +602,14 @@ private:
         GET_SYMBOL_DB("class Fred { void (*func(int f))(char) { } };\n")
 
         // 3 scopes: Global, Class, and Function
-        ASSERT(db && db->scopeList.size() == 3 && tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 3);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->tokAt(6));
 
             ASSERT(scope && scope->className == "func");
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->tokAt(6));
+            const Function *function = db->findFunctionByName("func", &db->scopeList.back());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->tokAt(6));
@@ -621,14 +621,14 @@ private:
         GET_SYMBOL_DB("class Fred { void (*func(int f))(char); };\n")
 
         // 2 scopes: Global and Class (no Function scope because there is no function implementation)
-        ASSERT(db && db->scopeList.size() == 2 && !tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 2);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->tokAt(6));
 
             ASSERT(scope == NULL);
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->tokAt(6));
+            const Function *function = db->findFunctionByName("func", &db->scopeList.back());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->tokAt(6));
@@ -640,14 +640,14 @@ private:
         GET_SYMBOL_DB("class Fred { void (*func(int f))(char); }; void (*Fred::func(int f))(char) { }\n")
 
         // 3 scopes: Global, Class, and Function
-        ASSERT(db && db->scopeList.size() == 3 && tokenizer.getFunctionTokenByName("func"));
+        ASSERT(db && db->scopeList.size() == 3);
 
         if (db) {
             const Scope *scope = db->findFunctionScopeByToken(tokenizer.tokens()->tokAt(23));
 
             ASSERT(scope && scope->className == "func");
 
-            const Function *function = db->findFunctionByToken(tokenizer.tokens()->tokAt(23));
+            const Function *function = db->findFunctionByName("func", &db->scopeList.back());
 
             ASSERT(function && function->token->str() == "func");
             ASSERT(function && function->token == tokenizer.tokens()->tokAt(23));
@@ -659,7 +659,7 @@ private:
         GET_SYMBOL_DB("std::map<int, string> foo() {}")
 
         // 2 scopes: Global and Function
-        ASSERT(db && db->scopeList.size() == 2 && tokenizer.getFunctionTokenByName("foo"));
+        ASSERT(db && db->scopeList.size() == 2 && db->findFunctionByName("foo", &db->scopeList.back()));
 
         if (db) {
             const Scope *scope = &db->scopeList.front();
@@ -677,7 +677,7 @@ private:
         GET_SYMBOL_DB("void foo();\nvoid foo();\nint foo(int i);\nvoid foo() {}")
 
         // 2 scopes: Global and Function
-        ASSERT(db && db->scopeList.size() == 2 && tokenizer.getFunctionTokenByName("foo"));
+        ASSERT(db && db->scopeList.size() == 2 && db->findFunctionByName("foo", &db->scopeList.back()));
 
         if (db) {
             const Scope *scope = &db->scopeList.front();
@@ -725,8 +725,8 @@ private:
         // 3 scopes: Global, function, if
         ASSERT_EQUALS(3, db->scopeList.size());
 
-        ASSERT(tokenizer.getFunctionTokenByName("func") != NULL);
-        ASSERT(tokenizer.getFunctionTokenByName("if") == NULL);
+        ASSERT(db->findFunctionByName("func", &db->scopeList.back()) != NULL);
+        ASSERT(db->findFunctionByName("if", &db->scopeList.back()) == NULL);
     }
 
     void parseFunctionDeclarationCorrect() {