{

if (nullptr==ptr)

return false;

char a;

if (bStackBelowHeap)

return ptr < &a;

else

return ptr > &a;

{

int type = -1;

pid_t killid;

// TODO: separate these two defines

#if defined(__linux__) && defined(REG_ERR)

const ucontext_t* const uc = reinterpret_cast<const ucontext_t*>(context);

killid = (pid_t) syscall(SYS_gettid);

if (uc) {

type = (int)uc->uc_mcontext.gregs[REG_ERR] & 2;

}

#else

(void)context;

killid = getpid();

#endif

const Signalmap_t::const_iterator it=listofsignals.find(signo);

const char * const signame = (it==listofsignals.end()) ? "unknown" : it->second.c_str();

bool printCallstack=true; // try to print a callstack?

bool lowMem=false; // was low-memory condition detected? Be careful then! Avoid allocating much more memory then.

bool unexpectedSignal=true; // unexpected indicates program failure

bool terminate=true; // exit process/thread

const bool isAddressOnStack = IsAddressOnStack(info->si_addr);

FILE* output = CppCheckExecutor::getExceptionOutput();

switch (signo) {

case SIGABRT:

fputs("Internal error: cppcheck received signal ", output);

fputs(signame, output);

fputs(

#ifdef NDEBUG

" - out of memory?\n",

#else

" - out of memory or assertion?\n",

#endif

output);

lowMem=true; // educated guess

break;

case SIGBUS:

fputs("Internal error: cppcheck received signal ", output);

fputs(signame, output);

switch (info->si_code) {

case BUS_ADRALN: // invalid address alignment

fputs(" - BUS_ADRALN", output);

break;

case BUS_ADRERR: // nonexistent physical address

fputs(" - BUS_ADRERR", output);

break;

case BUS_OBJERR: // object-specific hardware error

fputs(" - BUS_OBJERR", output);

break;

#ifdef BUS_MCEERR_AR

case BUS_MCEERR_AR: // Hardware memory error consumed on a machine check;

fputs(" - BUS_MCEERR_AR", output);

break;

#endif

#ifdef BUS_MCEERR_AO

case BUS_MCEERR_AO: // Hardware memory error detected in process but not consumed

fputs(" - BUS_MCEERR_AO", output);

break;

#endif

default:

break;

}

fprintf(output, " (at 0x%lx).\n",

(unsigned long)info->si_addr);

break;

case SIGFPE:

fputs("Internal error: cppcheck received signal ", output);

fputs(signame, output);

switch (info->si_code) {

case FPE_INTDIV: // integer divide by zero

fputs(" - FPE_INTDIV", output);

break;

case FPE_INTOVF: // integer overflow

fputs(" - FPE_INTOVF", output);

break;

case FPE_FLTDIV: // floating-point divide by zero

fputs(" - FPE_FLTDIV", output);

break;

case FPE_FLTOVF: // floating-point overflow

fputs(" - FPE_FLTOVF", output);

break;

case FPE_FLTUND: // floating-point underflow

fputs(" - FPE_FLTUND", output);

break;

case FPE_FLTRES: // floating-point inexact result

fputs(" - FPE_FLTRES", output);

break;

case FPE_FLTINV: // floating-point invalid operation

fputs(" - FPE_FLTINV", output);

break;

case FPE_FLTSUB: // subscript out of range

fputs(" - FPE_FLTSUB", output);

break;

default:

break;

}

fprintf(output, " (at 0x%lx).\n",

(unsigned long)info->si_addr);

break;

case SIGILL:

fputs("Internal error: cppcheck received signal ", output);

fputs(signame, output);

switch (info->si_code) {

case ILL_ILLOPC: // illegal opcode

fputs(" - ILL_ILLOPC", output);

break;

case ILL_ILLOPN: // illegal operand

fputs(" - ILL_ILLOPN", output);

break;

case ILL_ILLADR: // illegal addressing mode

fputs(" - ILL_ILLADR", output);

break;

case ILL_ILLTRP: // illegal trap

fputs(" - ILL_ILLTRP", output);

break;

case ILL_PRVOPC: // privileged opcode

fputs(" - ILL_PRVOPC", output);

break;

case ILL_PRVREG: // privileged register

fputs(" - ILL_PRVREG", output);

break;

case ILL_COPROC: // coprocessor error

fputs(" - ILL_COPROC", output);

break;

case ILL_BADSTK: // internal stack error

fputs(" - ILL_BADSTK", output);

break;

default:

break;

}

fprintf(output, " (at 0x%lx).%s\n",

(unsigned long)info->si_addr,

(isAddressOnStack)?" Stackoverflow?":"");

break;

case SIGINT:

unexpectedSignal=false; // legal usage: interrupt application via CTRL-C

fputs("cppcheck received signal ", output);

fputs(signame, output);

printCallstack=true;

fputs(".\n", output);

break;

case SIGSEGV:

fputs("Internal error: cppcheck received signal ", output);

fputs(signame, output);

switch (info->si_code) {

case SEGV_MAPERR: // address not mapped to object

fputs(" - SEGV_MAPERR", output);

break;

case SEGV_ACCERR: // invalid permissions for mapped object

fputs(" - SEGV_ACCERR", output);

break;

default:

break;

}

fprintf(output, " (%sat 0x%lx).%s\n",

// cppcheck-suppress knownConditionTrueFalse ; FP

(type==-1)? "" :

(type==0) ? "reading " : "writing ",

(unsigned long)info->si_addr,

(isAddressOnStack)?" Stackoverflow?":""

);

break;

case SIGUSR1:

fputs("cppcheck received signal ", output);

fputs(signame, output);

fputs(".\n", output);

terminate=false;

break;

default:

fputs("Internal error: cppcheck received signal ", output);

fputs(signame, output);

fputs(".\n", output);

break;

}

if (printCallstack) {

#ifdef USE_UNIX_BACKTRACE_SUPPORT

print_stacktrace(output, true, -1, lowMem);

#endif

}

if (unexpectedSignal) {

fputs("\nPlease report this to the cppcheck developers!\n", output);

}

fflush(output);

if (terminate) {

// now let things proceed, shutdown and hopefully dump core for post-mortem analysis

struct sigaction act;

memset(&act, 0, sizeof(act));

act.sa_handler=SIG_DFL;

sigaction(signo, &act, nullptr);

kill(killid, signo);

}

{

// determine stack vs. heap

char stackVariable;

char *heapVariable=(char*)malloc(1);

bStackBelowHeap = &stackVariable < heapVariable;

free(heapVariable);

// set up alternative stack for signal handler

stack_t segv_stack;

segv_stack.ss_sp = mytstack;

segv_stack.ss_flags = 0;

segv_stack.ss_size = MYSTACKSIZE;

sigaltstack(&segv_stack, nullptr);

// install signal handler

struct sigaction act;

memset(&act, 0, sizeof(act));

act.sa_flags=SA_SIGINFO|SA_ONSTACK;

act.sa_sigaction=CppcheckSignalHandler;

for (std::map<int, std::string>::const_iterator sig=listofsignals.cbegin(); sig!=listofsignals.cend(); ++sig) {

sigaction(sig->first, &act, nullptr);

}

return (&executor->*f)(cppcheck);