option.c

debug source code under unix platform.

                    h->flags &= ~FLG_CHECKFREES;
                break;
              case OPT_CHECKMEMORY:
                if (u == 0)
                    h->flags |= FLG_CHECKMEMORY;
                else
                    h->flags &= ~FLG_CHECKMEMORY;
                break;
              case OPT_LOGALLOCS:
                if (u == 0)
                    h->flags |= FLG_LOGALLOCS;
                else
                    h->flags &= ~FLG_LOGALLOCS;
                break;
              case OPT_LOGREALLOCS:
                if (u == 0)
                    h->flags |= FLG_LOGREALLOCS;
                else
                    h->flags &= ~FLG_LOGREALLOCS;
                break;
              case OPT_LOGFREES:
                if (u == 0)
                    h->flags |= FLG_LOGFREES;
                else
                    h->flags &= ~FLG_LOGFREES;
                break;
              case OPT_LOGMEMORY:
                if (u == 0)
                    h->flags |= FLG_LOGMEMORY;
                else
                    h->flags &= ~FLG_LOGMEMORY;
                break;
              case OPT_SHOWMAP:
                if (u == 0)
                    h->flags |= FLG_SHOWMAP;
                else
                    h->flags &= ~FLG_SHOWMAP;
                break;
              case OPT_SHOWSYMBOLS:
                if (u == 0)
                    h->flags |= FLG_SHOWSYMBOLS;
                else
                    h->flags &= ~FLG_SHOWSYMBOLS;
                break;
              case OPT_SHOWFREE:
                if (u == 0)
                    h->flags |= FLG_SHOWFREE;
                else
                    h->flags &= ~FLG_SHOWFREE;
                break;
              case OPT_SHOWFREED:
                if (u == 0)
                    h->flags |= FLG_SHOWFREED;
                else
                    h->flags &= ~FLG_SHOWFREED;
                break;
              case OPT_SHOWUNFREED:
                if (u == 0)
                    h->flags |= FLG_SHOWUNFREED;
                else
                    h->flags &= ~FLG_SHOWUNFREED;
                break;
              case OPT_LEAKTABLE:
                if (u == 0)
                {
                    h->flags |= FLG_LEAKTABLE;
                    h->ltable.tracing = 1;
                }
                else
                {
                    h->flags &= ~FLG_LEAKTABLE;
                    h->ltable.tracing = 0;
                }
                break;
              case OPT_ALLOWOFLOW:
                if (u == 0)
                    h->flags |= FLG_ALLOWOFLOW;
                else
                    h->flags &= ~FLG_ALLOWOFLOW;
                break;
              case OPT_CHECKFORK:
                if (u == 0)
                    h->flags |= FLG_CHECKFORK;
                else
                    h->flags &= ~FLG_CHECKFORK;
                break;
              case OPT_EDIT:
                if (u == 0)
                {
#if TARGET == TARGET_UNIX
                    __mp_diagflags &= ~FLG_LIST;
                    __mp_diagflags |= FLG_EDIT;
#endif /* TARGET */
                }
                else
                {
#if TARGET == TARGET_UNIX
                    __mp_diagflags &= ~FLG_EDIT;
#endif /* TARGET */
                }
                break;
              case OPT_LIST:
                if (u == 0)
                {
#if TARGET == TARGET_UNIX
                    __mp_diagflags &= ~FLG_EDIT;
                    __mp_diagflags |= FLG_LIST;
#endif /* TARGET */
                }
                else
                {
#if TARGET == TARGET_UNIX
                    __mp_diagflags &= ~FLG_LIST;
#endif /* TARGET */
                }
                break;
              default:
                f |= i;
                break;
            }
        }
    return f;
}


/* Set an mpatrol option after the library has been initialised.
 */

MP_GLOBAL
unsigned long
__mp_set(infohead *h, unsigned long o, unsigned long v)
{
    unsigned long r;

    r = 0;
    switch (o)
    {
      case OPT_HELP:
        showoptions();
        break;
      case OPT_SETFLAGS:
        r = setflags(h, v, 0);
        break;
      case OPT_UNSETFLAGS:
        r = setflags(h, v, 1);
        break;
      case OPT_ALLOCSTOP:
        h->astop = v;
        break;
      case OPT_REALLOCSTOP:
        h->rstop = v;
        break;
      case OPT_FREESTOP:
        h->fstop = v;
        break;
      case OPT_ALLOCBYTE:
        if (v > 0xFF)
            v = 0xFF;
        h->alloc.abyte = v;
        break;
      case OPT_DEFALIGN:
        if ((v == 0) || (v > h->alloc.heap.memory.page))
            r = o;
        else
            h->alloc.heap.memory.align = __mp_poweroftwo(v);
        break;
      case OPT_LIMIT:
        h->limit = v;
        break;
      case OPT_FAILFREQ:
        h->ffreq = v;
        break;
      case OPT_FAILSEED:
        if (v == 0)
            v = (unsigned long) time(NULL);
        srand((unsigned int) v);
        h->fseed = v;
        break;
      case OPT_UNFREEDABORT:
        h->uabort = v;
        break;
      case OPT_AUTOSAVE:
        if (h->prof.autocount > 0)
            __mp_writeprofile(&h->prof, !(h->flags & FLG_NOPROTECT));
        h->prof.autosave = v;
        break;
      case OPT_CHECKLOWER:
        h->lrange = v;
        break;
      case OPT_CHECKUPPER:
        h->urange = v;
        break;
      case OPT_CHECKFREQ:
        if (v == 0)
            v = 1;
        h->check = v;
        break;
      case OPT_NOFREE:
        while (h->alloc.flist.size > v)
            __mp_recyclefreed(&h->alloc);
        if (h->alloc.fmax = v)
            h->alloc.flags |= FLG_NOFREE;
        else
            h->alloc.flags &= ~FLG_NOFREE;
        break;
      default:
        r = o;
        break;
    }
    return r;
}


/* Get mpatrol flags after the library has been initialised.
 */

static
unsigned long
getflags(infohead *h)
{
    unsigned long f;

    f = 0;
    if (h->flags & FLG_CHECKALLOCS)
        f |= OPT_CHECKALLOCS;
    if (h->flags & FLG_CHECKREALLOCS)
        f |= OPT_CHECKREALLOCS;
    if (h->flags & FLG_CHECKFREES)
        f |= OPT_CHECKFREES;
    if (h->flags & FLG_CHECKMEMORY)
        f |= OPT_CHECKMEMORY;
    if (h->flags & FLG_LOGALLOCS)
        f |= OPT_LOGALLOCS;
    if (h->flags & FLG_LOGREALLOCS)
        f |= OPT_LOGREALLOCS;
    if (h->flags & FLG_LOGFREES)
        f |= OPT_LOGFREES;
    if (h->flags & FLG_LOGMEMORY)
        f |= OPT_LOGMEMORY;
    if (h->flags & FLG_SHOWMAP)
        f |= OPT_SHOWMAP;
    if (h->flags & FLG_SHOWSYMBOLS)
        f |= OPT_SHOWSYMBOLS;
    if (h->flags & FLG_SHOWFREE)
        f |= OPT_SHOWFREE;
    if (h->flags & FLG_SHOWFREED)
        f |= OPT_SHOWFREED;
    if (h->flags & FLG_SHOWUNFREED)
        f |= OPT_SHOWUNFREED;
    if (h->flags & FLG_LEAKTABLE)
        f |= OPT_LEAKTABLE;
    if (h->flags & FLG_ALLOWOFLOW)
        f |= OPT_ALLOWOFLOW;
    if (h->prof.profiling)
        f |= OPT_PROF;
    if (h->trace.tracing)
        f |= OPT_TRACE;
    if (h->flags & FLG_SAFESIGNALS)
        f |= OPT_SAFESIGNALS;
    if (h->flags & FLG_NOPROTECT)
        f |= OPT_NOPROTECT;
    if (h->flags & FLG_CHECKFORK)
        f |= OPT_CHECKFORK;
    if (h->alloc.flags & FLG_PRESERVE)
        f |= OPT_PRESERVE;
    if (h->alloc.flags & FLG_OFLOWWATCH)
        f |= OPT_OFLOWWATCH;
    if (h->alloc.flags & FLG_PAGEALLOC)
        f |= OPT_PAGEALLOC;
    if (h->alloc.flags & FLG_ALLOCUPPER)
        f |= OPT_ALLOCUPPER;
    if (h->alloc.heap.memory.flags & FLG_USEMMAP)
        f |= OPT_USEMMAP;
    if (h->syms.lineinfo)
        f |= OPT_USEDEBUG;
    if (__mp_diagflags & FLG_EDIT)
        f |= OPT_EDIT;
    if (__mp_diagflags & FLG_LIST)
        f |= OPT_LIST;
    if (__mp_diagflags & FLG_HTML)
        f |= OPT_HTML;
    return f;
}


/* Get an mpatrol option after the library has been initialised.
 */

MP_GLOBAL
int
__mp_get(infohead *h, unsigned long o, unsigned long *v)
{
    int r;

    r = 1;
    switch (o)
    {
      case OPT_HELP:
        *v = 0;
        break;
      case OPT_SETFLAGS:
        *v = getflags(h);
        break;
      case OPT_UNSETFLAGS:
        *v = ~getflags(h);
        break;
      case OPT_ALLOCSTOP:
        *v = h->astop;
        break;
      case OPT_REALLOCSTOP:
        *v = h->rstop;
        break;
      case OPT_FREESTOP:
        *v = h->fstop;
        break;
      case OPT_ALLOCBYTE:
        *v = h->alloc.abyte;
        break;
      case OPT_FREEBYTE:
        *v = h->alloc.fbyte;
        break;
      case OPT_OFLOWBYTE:
        *v = h->alloc.obyte;
        break;
      case OPT_OFLOWSIZE:
        *v = h->alloc.oflow;
        break;
      case OPT_DEFALIGN:
        *v = h->alloc.heap.memory.align;
        break;
      case OPT_LIMIT:
        *v = h->limit;
        break;
      case OPT_FAILFREQ:
        *v = h->ffreq;
        break;
      case OPT_FAILSEED:
        *v = h->fseed;
        break;
      case OPT_UNFREEDABORT:
        *v = h->uabort;
        break;
      case OPT_LOGFILE:
        *v = (unsigned long) h->log;
        break;
      case OPT_PROFFILE:
        *v = (unsigned long) h->prof.file;
        break;
      case OPT_TRACEFILE:
        *v = (unsigned long) h->trace.file;
        break;
      case OPT_PROGFILE:
        *v = (unsigned long) h->alloc.heap.memory.prog;
        break;
      case OPT_AUTOSAVE:
        *v = h->prof.autosave;
        break;
      case OPT_CHECKLOWER:
        *v = h->lrange;
        break;
      case OPT_CHECKUPPER:
        *v = h->urange;
        break;
      case OPT_CHECKFREQ:
        *v = h->check;
        break;
      case OPT_NOFREE:
        *v = h->alloc.fmax;
        break;
      case OPT_SMALLBOUND:
        *v = h->prof.sbound;
        break;
      case OPT_MEDIUMBOUND:
        *v = h->prof.mbound;
        break;
      case OPT_LARGEBOUND:
        *v = h->prof.lbound;
        break;
      default:
        r = 0;
        break;
    }
    return r;
}


#ifdef __cplusplus
}
#endif /* __cplusplus */