/*
 * Cppcheck - A tool for static C/C++ code analysis
 * Copyright (C) 2007-2014 Daniel Marjamäki and Cppcheck team.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "cppcheckexecutor.h"
#include "cmdlineparser.h"
#include "cppcheck.h"
#include "errorlogger.h"
#include "filelister.h"
#include "path.h"
#include "pathmatch.h"
#include "preprocessor.h"
#include "threadexecutor.h"

#include <climits>
#include <cstdlib> // EXIT_SUCCESS and EXIT_FAILURE
#include <cstring>
#include <algorithm>
#include <iostream>
#include <sstream>

#if !defined(NO_UNIX_SIGNAL_HANDLING) && defined(__GNUC__) && !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(__OS2__)
#define USE_UNIX_SIGNAL_HANDLING
#include <signal.h>
#include <cstdio>
#endif

#if !defined(NO_UNIX_BACKTRACE_SUPPORT) && defined(USE_UNIX_SIGNAL_HANDLING) && defined(__GNUC__) && !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(__SVR4)
#define USE_UNIX_BACKTRACE_SUPPORT
#include <cxxabi.h>
#include <execinfo.h>
#endif

#if defined(_MSC_VER)
#define USE_WINDOWS_SEH
#include <Windows.h>
#include <DbgHelp.h>
#include <excpt.h>
#include <TCHAR.H>
#endif

CppCheckExecutor::CppCheckExecutor()
    : _settings(0), time1(0), errorlist(false)
{
}

CppCheckExecutor::~CppCheckExecutor()
{
}

bool CppCheckExecutor::parseFromArgs(CppCheck *cppcheck, int argc, const char* const argv[])
{
    Settings& settings = cppcheck->settings();
    CmdLineParser parser(&settings);
    const bool success = parser.ParseFromArgs(argc, argv);

    if (success) {
        if (parser.GetShowVersion() && !parser.GetShowErrorMessages()) {
            const char * extraVersion = cppcheck->extraVersion();
            if (*extraVersion != 0)
                std::cout << "Cppcheck " << cppcheck->version() << " ("
                          << extraVersion << ')' << std::endl;
            else
                std::cout << "Cppcheck " << cppcheck->version() << std::endl;
        }

        if (parser.GetShowErrorMessages()) {
            errorlist = true;
            std::cout << ErrorLogger::ErrorMessage::getXMLHeader(settings._xml_version);
            cppcheck->getErrorMessages();
            std::cout << ErrorLogger::ErrorMessage::getXMLFooter(settings._xml_version) << std::endl;
        }

        if (parser.ExitAfterPrinting()) {
            settings.terminate();
            return true;
        }
    } else {
        return false;
    }

    // Check that all include paths exist
    {
        std::list<std::string>::iterator iter;
        for (iter = settings._includePaths.begin();
             iter != settings._includePaths.end();
            ) {
            const std::string path(Path::toNativeSeparators(*iter));
            if (FileLister::isDirectory(path))
                ++iter;
            else {
                // If the include path is not found, warn user (unless --quiet
                // was used) and remove the non-existing path from the list.
                if (!settings._errorsOnly)
                    std::cout << "cppcheck: warning: Couldn't find path given by -I '" << path << '\'' << std::endl;
                iter = settings._includePaths.erase(iter);
            }
        }
    }

    const std::vector<std::string>& pathnames = parser.GetPathNames();

    if (!pathnames.empty()) {
        // Execute recursiveAddFiles() to each given file parameter
        std::vector<std::string>::const_iterator iter;
        for (iter = pathnames.begin(); iter != pathnames.end(); ++iter)
            FileLister::recursiveAddFiles(_files, Path::toNativeSeparators(*iter), _settings->library.markupExtensions());
    }

    if (!_files.empty()) {
        // Remove header files from the list of ignored files.
        // Also output a warning for the user.
        // TODO: Remove all unknown files? (use FileLister::acceptFile())
        bool warn = false;
        std::vector<std::string> ignored = parser.GetIgnoredPaths();
        for (std::vector<std::string>::iterator i = ignored.begin(); i != ignored.end();) {
            const std::string extension = Path::getFilenameExtension(*i);
            if (extension == ".h" || extension == ".hpp") {
                i = ignored.erase(i);
                warn = true;
            } else
                ++i;
        }
        if (warn) {
            std::cout << "cppcheck: filename exclusion does not apply to header (.h and .hpp) files." << std::endl;
            std::cout << "cppcheck: Please use --suppress for ignoring results from the header files." << std::endl;
        }

#if defined(_WIN32)
        // For Windows we want case-insensitive path matching
        const bool caseSensitive = false;
#else
        const bool caseSensitive = true;
#endif
        PathMatch matcher(parser.GetIgnoredPaths(), caseSensitive);
        for (std::map<std::string, std::size_t>::iterator i = _files.begin(); i != _files.end();) {
            if (matcher.Match(i->first))
                _files.erase(i++);
            else
                ++i;
        }
    } else {
        std::cout << "cppcheck: error: could not find or open any of the paths given." << std::endl;
        return false;
    }

    if (!_files.empty()) {
        return true;
    } else {
        std::cout << "cppcheck: error: no files to check - all paths ignored." << std::endl;
        return false;
    }
}

int CppCheckExecutor::check(int argc, const char* const argv[])
{
    Preprocessor::missingIncludeFlag = false;
    Preprocessor::missingSystemIncludeFlag = false;

    CppCheck cppCheck(*this, true);

    Settings& settings = cppCheck.settings();
    _settings = &settings;

    if (!parseFromArgs(&cppCheck, argc, argv)) {
        return EXIT_FAILURE;
    }
    if (settings.terminated()) {
        return EXIT_SUCCESS;
    }

    if (cppCheck.settings().exceptionHandling) {
        return check_wrapper(cppCheck, argc, argv);
    } else {
        return check_internal(cppCheck, argc, argv);
    }
}

/**
 *  Simple helper function:
 * \return size of array
 * */
template<typename T, int size>
size_t GetArrayLength(const T(&)[size])
{
    return size;
}


#if defined(USE_UNIX_SIGNAL_HANDLING)
/* (declare this list here, so it may be used in signal handlers in addition to main())
 * A list of signals available in ISO C
 * Check out http://pubs.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html
 * For now we only want to detect abnormal behaviour for a few selected signals:
 */
struct Signaltype {
    int signalnumber;
    const char *signalname;
};
#define DECLARE_SIGNAL(x) {x, #x}
static const Signaltype listofsignals[] = {
    // don't care: SIGABRT,
    DECLARE_SIGNAL(SIGBUS),
    DECLARE_SIGNAL(SIGFPE),
    DECLARE_SIGNAL(SIGILL),
    DECLARE_SIGNAL(SIGINT),
    DECLARE_SIGNAL(SIGSEGV),
    // don't care: SIGTERM
};

/*
 * Simple mapping
 */
static const char *signal_name(int signo)
{
    for (size_t s=0; s<GetArrayLength(listofsignals); ++s) {
        if (listofsignals[s].signalnumber==signo)
            return listofsignals[s].signalname;
    }
    return "";
}


// 32 vs. 64bit
#define ADDRESSDISPLAYLENGTH ((sizeof(long)==8)?12:8)

/*
 * Try to print the callstack.
 * That is very sensitive to the operating system, hardware, compiler and runtime!
 * The code is not meant for production environment, it's using functions not whitelisted for usage in a signal handler function.
 */
static void print_stacktrace(FILE* f, bool demangling)
{
#if defined(USE_UNIX_BACKTRACE_SUPPORT)
    void *array[32]= {0}; // the less resources the better...
    const int depth = backtrace(array, (int)GetArrayLength(array));
    char **symbolstrings = backtrace_symbols(array, depth);
    if (symbolstrings) {
        fputs("Callstack:\n", f);
        const int offset=3; // the first two entries are simply within our own exception handling code, third is within libc
        for (int i = offset; i < depth; ++i) {
            const char * const symbol = symbolstrings[i];
            char * realname = nullptr;
            const char * const firstBracketName = strchr(symbol, '(');
            const char * const firstBracketAddress = strchr(symbol, '[');
            const char * const secondBracketAddress = strchr(firstBracketAddress, ']');
            const char * const beginAddress = firstBracketAddress+3;
            const int addressLen = int(secondBracketAddress-beginAddress);
            const int padLen = int(ADDRESSDISPLAYLENGTH-addressLen);
            if (demangling && firstBracketName) {
                const char * const plus = strchr(firstBracketName, '+');
                if (plus && (plus>(firstBracketName+1))) {
                    char input_buffer[512]= {0};
                    strncpy(input_buffer, firstBracketName+1, plus-firstBracketName-1);
                    char output_buffer[1024]= {0};
                    size_t length = GetArrayLength(output_buffer);
                    int status=0;
                    realname = abi::__cxa_demangle(input_buffer, output_buffer, &length, &status); // non-NULL on success
                }
            }
            const int ordinal=i-offset;
            fprintf(f, "#%-2d 0x",
                    ordinal);
            if (padLen>0)
                fprintf(f, "%0*d",
                        padLen, 0);
            if (realname) {
                fprintf(f, "%.*s in %s\n",
                        (int)(secondBracketAddress-firstBracketAddress-3), firstBracketAddress+3,
                        realname);
            } else {
                fprintf(f, "%.*s in %.*s\n",
                        (int)(secondBracketAddress-firstBracketAddress-3), firstBracketAddress+3,
                        (int)(firstBracketAddress-symbol), symbol);
            }
        }
        free(symbolstrings);
    } else {
        fputs("Callstack could not be obtained\n", f);
    }
#endif
}

/*
 * Entry pointer for signal handlers
 */
static void CppcheckSignalHandler(int signo, siginfo_t * info, void * /*context*/)
{
    const char * const signame = signal_name(signo);
    const char * const sigtext = strsignal(signo);
    bool bPrintCallstack=true;
    FILE* f=CppCheckExecutor::getExceptionOutput()=="stderr" ? stderr : stdout;
    fputs("Internal error: cppcheck received signal ", f);
    fputs(signame, f);
    fputs(", ", f);
    fputs(sigtext, f);
    switch (signo) {
    case SIGBUS:
        switch (info->si_code) {
        case BUS_ADRALN: // invalid address alignment
            fprintf(f, " - BUS_ADRALN");
            break;
        case BUS_ADRERR: // nonexistent physical address
            fprintf(f, " - BUS_ADRERR");
            break;
        case BUS_OBJERR: // object-specific hardware error
            fprintf(f, " - BUS_OBJERR");
            break;
#ifdef BUS_MCEERR_AR
        case BUS_MCEERR_AR: // Hardware memory error consumed on a machine check;
            fprintf(f, " - BUS_MCEERR_AR");
            break;
#endif
#ifdef BUS_MCEERR_AO
        case BUS_MCEERR_AO: // Hardware memory error detected in process but not consumed
            fprintf(f, " - BUS_MCEERR_AO");
            break;
#endif
        default:
            break;
        }
        fprintf(f, " (at 0x%p).\n",
                info->si_addr);
        break;
    case SIGFPE:
        switch (info->si_code) {
        case FPE_INTDIV: //     integer divide by zero
            fprintf(f, " - FPE_INTDIV");
            break;
        case FPE_INTOVF: //     integer overflow
            fprintf(f, " - FPE_INTOVF");
            break;
        case FPE_FLTDIV: //     floating-point divide by zero
            fprintf(f, " - FPE_FLTDIV");
            break;
        case FPE_FLTOVF: //     floating-point overflow
            fprintf(f, " - FPE_FLTOVF");
            break;
        case FPE_FLTUND: //     floating-point underflow
            fprintf(f, " - FPE_FLTUND");
            break;
        case FPE_FLTRES: //     floating-point inexact result
            fprintf(f, " - FPE_FLTRES");
            break;
        case FPE_FLTINV: //     floating-point invalid operation
            fprintf(f, " - FPE_FLTINV");
            break;
        case FPE_FLTSUB: //     subscript out of range
            fprintf(f, " - FPE_FLTSUB");
            break;
        default:
            break;
        }
        fprintf(f, " (at 0x%p).\n",
                info->si_addr);
        break;
    case SIGILL:
        switch (info->si_code) {
        case ILL_ILLOPC: //     illegal opcode
            fprintf(f, " - ILL_ILLOPC");
            break;
        case ILL_ILLOPN: //    illegal operand
            fprintf(f, " - ILL_ILLOPN");
            break;
        case ILL_ILLADR: //    illegal addressing mode
            fprintf(f, " - ILL_ILLADR");
            break;
        case ILL_ILLTRP: //    illegal trap
            fprintf(f, " - ILL_ILLTRP");
            break;
        case ILL_PRVOPC: //    privileged opcode
            fprintf(f, " - ILL_PRVOPC");
            break;
        case ILL_PRVREG: //    privileged register
            fprintf(f, " - ILL_PRVREG");
            break;
        case ILL_COPROC: //    coprocessor error
            fprintf(f, " - ILL_COPROC");
            break;
        case ILL_BADSTK: //    internal stack error
            fprintf(f, " - ILL_BADSTK");
            break;
        default:
            break;
        }
        fprintf(f, " (at 0x%p).\n",
                info->si_addr);
        break;
    case SIGINT:
        bPrintCallstack=false;
        fprintf(f, ".\n");
        break;
    case SIGSEGV:
        switch (info->si_code) {
        case SEGV_MAPERR: //    address not mapped to object
            fprintf(f, " - SEGV_MAPERR");
            break;
        case SEGV_ACCERR: //    invalid permissions for mapped object
            fprintf(f, " - SEGV_ACCERR");
            break;
        default:
            break;
        }
        fprintf(f, " (at 0x%p).\n",
                info->si_addr);
        break;
    default:
        fputs(".\n", f);
        break;
    }
    if (bPrintCallstack) {
        print_stacktrace(f, true);
        fputs("\nPlease report this to the cppcheck developers!\n", f);
    }
    abort();
}
#endif

#ifdef USE_WINDOWS_SEH

static const ULONG maxnamelength = 512;
struct IMAGEHLP_SYMBOL64_EXT : public IMAGEHLP_SYMBOL64 {
	TCHAR NameExt[maxnamelength];
};
typedef BOOL (WINAPI *fpStackWalk64)(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64);
static fpStackWalk64 pStackWalk64;
typedef DWORD64 (WINAPI *fpSymGetModuleBase64)(HANDLE, DWORD64);
static fpSymGetModuleBase64 pSymGetModuleBase64;
typedef BOOL (WINAPI *fpSymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
static fpSymGetSymFromAddr64 pSymGetSymFromAddr64;
typedef BOOL (WINAPI *fpSymGetLineFromAddr64)(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
static fpSymGetLineFromAddr64 pSymGetLineFromAddr64; 
typedef DWORD (WINAPI *fpUnDecorateSymbolName)(  const TCHAR*, PTSTR, DWORD, DWORD) ;
static fpUnDecorateSymbolName pUnDecorateSymbolName; 
typedef PVOID (WINAPI *fpSymFunctionTableAccess64)(HANDLE, DWORD64);
static fpSymFunctionTableAccess64 pSymFunctionTableAccess64;
typedef BOOL (WINAPI *fpSymInitialize)(HANDLE, PCSTR, BOOL);
static fpSymInitialize pSymInitialize;

// avoid explicit dependency on Dbghelp.dll
static bool loadDbgHelp()
{
	HMODULE hLib = ::LoadLibraryW(L"Dbghelp.dll");
	if (!hLib)
		return true;
	pStackWalk64 = (fpStackWalk64) ::GetProcAddress(hLib, "StackWalk64");
	pSymGetModuleBase64 = (fpSymGetModuleBase64) ::GetProcAddress(hLib, "SymGetModuleBase64");
	pSymGetSymFromAddr64 = (fpSymGetSymFromAddr64) ::GetProcAddress(hLib, "SymGetSymFromAddr64");
	pSymGetLineFromAddr64 = (fpSymGetLineFromAddr64)::GetProcAddress(hLib, "SymGetLineFromAddr64");
	pSymFunctionTableAccess64 = (fpSymFunctionTableAccess64)::GetProcAddress(hLib, "SymFunctionTableAccess64");
	pSymInitialize = (fpSymInitialize) ::GetProcAddress(hLib, "SymInitialize");
	pUnDecorateSymbolName = (fpUnDecorateSymbolName)::GetProcAddress(hLib, "UnDecorateSymbolName");
	return true;
}


static void PrintCallstack(FILE* f, PEXCEPTION_POINTERS ex)
{
	if (!loadDbgHelp())
		return;
    const HANDLE hProcess   = GetCurrentProcess();
    const HANDLE hThread    = GetCurrentThread();
	BOOL result = pSymInitialize(
		hProcess,
		0,
		TRUE
	);
	CONTEXT             context = *(ex->ContextRecord);
	STACKFRAME64        stack={0};
#ifdef _M_IX86
    stack.AddrPC.Offset    = context.Eip;
    stack.AddrPC.Mode      = AddrModeFlat;
    stack.AddrStack.Offset = context.Esp;
    stack.AddrStack.Mode   = AddrModeFlat;
    stack.AddrFrame.Offset = context.Ebp;
    stack.AddrFrame.Mode   = AddrModeFlat;
#else
	stack.AddrPC.Offset    = context.Rip;
    stack.AddrPC.Mode      = AddrModeFlat;
    stack.AddrStack.Offset = context.Rsp;
    stack.AddrStack.Mode   = AddrModeFlat;
    stack.AddrFrame.Offset = context.Rsp;
    stack.AddrFrame.Mode   = AddrModeFlat;
#endif
	IMAGEHLP_SYMBOL64_EXT symbol;
	IMAGEHLP_SYMBOL64* pSymbol = &symbol;
    pSymbol->SizeOfStruct  = sizeof( IMAGEHLP_SYMBOL64 );
    pSymbol->MaxNameLength = maxnamelength;
	DWORD64 displacement   = 0;
	int beyond_main=-1; // emergency exit, see below
    for( ULONG frame = 0; ; frame++ )
    {
        result = pStackWalk64
        (
#ifdef _M_IX86
            IMAGE_FILE_MACHINE_I386,
#else
			IMAGE_FILE_MACHINE_AMD64,
#endif
            hProcess,
            hThread,
            &stack,
            &context,
            NULL,
            pSymFunctionTableAccess64,
            pSymGetModuleBase64,
            NULL
        );
        if( !result ) // official end...
            break;
        result = pSymGetSymFromAddr64( hProcess, ( ULONG64 )stack.AddrPC.Offset, &displacement, pSymbol );
		TCHAR undname[maxnamelength]={0};
		pUnDecorateSymbolName( (const TCHAR*)pSymbol->Name, (PTSTR)undname, GetArrayLength(undname), UNDNAME_COMPLETE );
		if (beyond_main>=0)
			++beyond_main;
		if (_tcscmp(undname, _T("main"))==0)
			beyond_main=0;
        fprintf( f,
            "%lu. 0x%08LX in ",
            frame, (ULONG64)stack.AddrPC.Offset);
		fputs((const char *)undname, f);
		fputs("\n", f);
		if (0==stack.AddrReturn.Offset || beyond_main>2) // StackWalk64() sometimes doesn't reach any end...
			break;
    }
}

/*
 * Any evaluation of the information about the exception needs to be done here!
 */
static int filterException(int code, PEXCEPTION_POINTERS ex)
{
    FILE *f = stdout;
    fputs("Internal error: ", f);
    switch (ex->ExceptionRecord->ExceptionCode) {
    case EXCEPTION_ACCESS_VIOLATION:
        fputs("Access violation", f);
        switch (ex->ExceptionRecord->ExceptionInformation[0]) {
        case 0:
            fprintf(f, " reading from 0x%x",
                    ex->ExceptionRecord->ExceptionInformation[1]);
            break;
        case 1:
            fprintf(f, " writing at 0x%x",
                    ex->ExceptionRecord->ExceptionInformation[1]);
            break;
        case 8:
            fprintf(f, " data execution prevention at 0x%x",
                    ex->ExceptionRecord->ExceptionInformation[1]);
            break;
        default:
            break;
        }
        break;
    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
        fputs("Out of array bounds", f);
        break;
    case EXCEPTION_BREAKPOINT:
        fputs("Breakpoint", f);
        break;
    case EXCEPTION_DATATYPE_MISALIGNMENT:
        fputs("Misaligned data", f);
        break;
    case EXCEPTION_FLT_DENORMAL_OPERAND:
        fputs("Denormalized floating-point value", f);
        break;
    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
        fputs("Floating-point divide-by-zero", f);
        break;
    case EXCEPTION_FLT_INEXACT_RESULT:
        fputs("Inexact floating-point value", f);
        break;
    case EXCEPTION_FLT_INVALID_OPERATION:
        fputs("Invalid floating-point operation", f);
        break;
    case EXCEPTION_FLT_OVERFLOW:
        fputs("Floating-point overflow", f);
        break;
    case EXCEPTION_FLT_STACK_CHECK:
        fputs("Floating-point stack overflow", f);
        break;
    case EXCEPTION_FLT_UNDERFLOW:
        fputs("Floating-point underflow", f);
        break;
    case EXCEPTION_GUARD_PAGE:
        fputs("Page-guard access", f);
        break;
    case EXCEPTION_ILLEGAL_INSTRUCTION:
        fputs("Illegal instruction", f);
        break;
    case EXCEPTION_IN_PAGE_ERROR:
        fputs("Invalid page access", f);
        switch (ex->ExceptionRecord->ExceptionInformation[0]) {
        case 0:
            fprintf(f, " reading from 0x%x",
                    ex->ExceptionRecord->ExceptionInformation[1]);
            break;
        case 1:
            fprintf(f, " writing at 0x%x",
                    ex->ExceptionRecord->ExceptionInformation[1]);
            break;
        case 8:
            fprintf(f, " data execution prevention at 0x%x",
                    ex->ExceptionRecord->ExceptionInformation[1]);
            break;
        default:
            break;
        }
        break;
    case EXCEPTION_INT_DIVIDE_BY_ZERO:
        fputs("Integer divide-by-zero", f);
        break;
    case EXCEPTION_INT_OVERFLOW:
        fputs("Integer overflow", f);
        break;
    case EXCEPTION_INVALID_DISPOSITION:
        fputs("Invalid exception dispatcher", f);
        break;
    case EXCEPTION_INVALID_HANDLE:
        fputs("Invalid handle", f);
        break;
    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
        fputs("Non-continuable exception", f);
        break;
    case EXCEPTION_PRIV_INSTRUCTION:
        fputs("Invalid instruction", f);
        break;
    case EXCEPTION_SINGLE_STEP:
        fputs("Single instruction step", f);
        break;
    case EXCEPTION_STACK_OVERFLOW:
        fputs("Stack overflow", f);
        break;
    default:
        fprintf(f, "Unknown exception (%d)\n",
                code);
        break;
    }
    fputs("\n", f);
	PrintCallstack(f, ex);
    return EXCEPTION_EXECUTE_HANDLER;
}
#endif

/**
 * Signal/SEH handling
 * Has to be clean for using with SEH on windows, i.e. no construction of C++ object instances is allowed!
 * TODO Check for multi-threading issues!
 *
 */
int CppCheckExecutor::check_wrapper(CppCheck& cppcheck, int argc, const char* const argv[])
{
#ifdef USE_WINDOWS_SEH
    FILE *f = stdout;
    __try {
        return check_internal(cppcheck, argc, argv);
    } __except (filterException(GetExceptionCode(), GetExceptionInformation())) {
        // reporting to stdout may not be helpful within a GUI application..
        fputs("Please report this to the cppcheck developers!\n", f);
        return -1;
    }
#elif defined(USE_UNIX_SIGNAL_HANDLING)
    struct sigaction act;
    memset(&act, 0, sizeof(act));
    act.sa_flags=SA_SIGINFO;
    act.sa_sigaction=CppcheckSignalHandler;
    for (std::size_t s=0; s<GetArrayLength(listofsignals); ++s) {
        sigaction(listofsignals[s].signalnumber, &act, NULL);
    }
    return check_internal(cppcheck, argc, argv);
#else
    return check_internal(cppcheck, argc, argv);
#endif
}

/*
 * That is a method which gets called from check_wrapper
 * */
int CppCheckExecutor::check_internal(CppCheck& cppcheck, int /*argc*/, const char* const argv[])
{
    Settings& settings = cppcheck.settings();
    _settings = &settings;
    bool std = (settings.library.load(argv[0], "std.cfg").errorcode == Library::OK);
    bool posix = true;
    if (settings.standards.posix)
        posix = (settings.library.load(argv[0], "posix.cfg").errorcode == Library::OK);

    if (!std || !posix) {
        const std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;
        const std::string msg("Failed to load " + std::string(!std ? "std.cfg" : "posix.cfg") + ". Your Cppcheck installation is broken, please re-install.");
#ifdef CFGDIR
        const std::string details("The Cppcheck binary was compiled with CFGDIR set to \"" +
                                  std::string(CFGDIR) + "\" and will therefore search for "
                                  "std.cfg in that path.");
#else
        const std::string cfgfolder(Path::fromNativeSeparators(Path::getPathFromFilename(argv[0])) + "cfg");
        const std::string details("The Cppcheck binary was compiled without CFGDIR set. Either the "
                                  "std.cfg should be available in " + cfgfolder + " or the CFGDIR "
                                  "should be configured.");
#endif
        ErrorLogger::ErrorMessage errmsg(callstack, Severity::information, msg+" "+details, "failedToLoadCfg", false);
        reportErr(errmsg);
        return EXIT_FAILURE;
    }

    if (settings.reportProgress)
        time1 = std::time(0);

    if (settings._xml) {
        reportErr(ErrorLogger::ErrorMessage::getXMLHeader(settings._xml_version));
    }

    unsigned int returnValue = 0;
    if (settings._jobs == 1) {
        // Single process

        std::size_t totalfilesize = 0;
        for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
            totalfilesize += i->second;
        }

        std::size_t processedsize = 0;
        unsigned int c = 0;
        for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
            if (!_settings->library.markupFile(i->first)
                || !_settings->library.processMarkupAfterCode(i->first)) {
                returnValue += cppcheck.check(i->first);
                processedsize += i->second;
                if (!settings._errorsOnly)
                    reportStatus(c + 1, _files.size(), processedsize, totalfilesize);
                c++;
            }
        }

        // second loop to parse all markup files which may not work until all
        // c/cpp files have been parsed and checked
        for (std::map<std::string, std::size_t>::const_iterator i = _files.begin(); i != _files.end(); ++i) {
            if (_settings->library.markupFile(i->first) && _settings->library.processMarkupAfterCode(i->first)) {
                returnValue += cppcheck.check(i->first);
                processedsize += i->second;
                if (!settings._errorsOnly)
                    reportStatus(c + 1, _files.size(), processedsize, totalfilesize);
                c++;
            }
        }

        cppcheck.checkFunctionUsage();
    } else if (!ThreadExecutor::isEnabled()) {
        std::cout << "No thread support yet implemented for this platform." << std::endl;
    } else {
        // Multiple processes
        ThreadExecutor executor(_files, settings, *this);
        returnValue = executor.check();
    }

    if (settings.isEnabled("information") || settings.checkConfiguration)
        reportUnmatchedSuppressions(settings.nomsg.getUnmatchedGlobalSuppressions());

    if (!settings.checkConfiguration) {
        cppcheck.tooManyConfigsError("",0U);

        if (settings.isEnabled("missingInclude") && (Preprocessor::missingIncludeFlag || Preprocessor::missingSystemIncludeFlag)) {
            const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack;
            ErrorLogger::ErrorMessage msg(callStack,
                                          Severity::information,
                                          "Cppcheck cannot find all the include files (use --check-config for details)\n"
                                          "Cppcheck cannot find all the include files. Cppcheck can check the code without the "
                                          "include files found. But the results will probably be more accurate if all the include "
                                          "files are found. Please check your project's include directories and add all of them "
                                          "as include directories for Cppcheck. To see what files Cppcheck cannot find use "
                                          "--check-config.",
                                          Preprocessor::missingIncludeFlag ? "missingInclude" : "missingIncludeSystem",
                                          false);
            reportInfo(msg);
        }
    }

    if (settings._xml) {
        reportErr(ErrorLogger::ErrorMessage::getXMLFooter(settings._xml_version));
    }

    _settings = 0;
    if (returnValue)
        return settings._exitCode;
    else
        return 0;
}

void CppCheckExecutor::reportErr(const std::string &errmsg)
{
    // Alert only about unique errors
    if (_errorList.find(errmsg) != _errorList.end())
        return;

    _errorList.insert(errmsg);
    std::cerr << errmsg << std::endl;
}

void CppCheckExecutor::reportOut(const std::string &outmsg)
{
    std::cout << outmsg << std::endl;
}

void CppCheckExecutor::reportProgress(const std::string &filename, const char stage[], const std::size_t value)
{
    (void)filename;

    if (!time1)
        return;

    // Report progress messages every 10 seconds
    const std::time_t time2 = std::time(NULL);
    if (time2 >= (time1 + 10)) {
        time1 = time2;

        // format a progress message
        std::ostringstream ostr;
        ostr << "progress: "
             << stage
             << ' ' << value << '%';

        // Report progress message
        reportOut(ostr.str());
    }
}

void CppCheckExecutor::reportInfo(const ErrorLogger::ErrorMessage &msg)
{
    reportErr(msg);
}

void CppCheckExecutor::reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal)
{
    if (filecount > 1) {
        std::ostringstream oss;
        oss << fileindex << '/' << filecount
            << " files checked " <<
            (sizetotal > 0 ? static_cast<long>(static_cast<long double>(sizedone) / sizetotal*100) : 0)
            << "% done";
        std::cout << oss.str() << std::endl;
    }
}

void CppCheckExecutor::reportErr(const ErrorLogger::ErrorMessage &msg)
{
    if (errorlist) {
        reportOut(msg.toXML(false, _settings->_xml_version));
    } else if (_settings->_xml) {
        reportErr(msg.toXML(_settings->_verbose, _settings->_xml_version));
    } else {
        reportErr(msg.toString(_settings->_verbose, _settings->_outputFormat));
    }
}

void CppCheckExecutor::setExceptionOutput(const std::string& fn)
{
    exceptionOutput=fn;
}

const std::string& CppCheckExecutor::getExceptionOutput()
{
    return exceptionOutput;
}

std::string CppCheckExecutor::exceptionOutput;