UT/UT_StackTrace.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Paul Breslin    (with code from SGI, see UT_StackTrace.C)
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_StackTrace.h ( UT Library, C++)
 *
 * COMMENTS:
 *      Debugging utility to print stack tracebacks from anywhere in
 *      the code. Example usage:
 *
 *      #include <UT/UT_StackTrace.h>
 *      UT_StackTrace   tracer(stderr);
 *      tracer.doTraceback("in load method");
 *
 *      From inside a signal handler use as follows:
 *
 *      void sig_handler( UTsignalHandlerArg sig_arg)
 *      {
 *          UT_StackTrace       tracer;
 *
 *          tracer.doTraceback(sig_arg, "inside sig_handler");
 *          ...
 *      }
 *
 *      Note: On Irix, you must link with "-lexc" to use this class.
 */

#ifndef __UT_StackTrace__
#define __UT_StackTrace__

#include "UT_API.h"
#include <stdio.h>
#include "UT_Signal.h"
#include "UT_Debug.h"
class UT_WorkBuffer;

#define TRACE_STACK()         { UT_StackTrace tr; tr.doTraceback(); }
#define TRACE_STACK_LIMIT(lm) { UT_StackTrace tr; tr.setMaxStackLevel(lm); \
                                tr.doTraceback(); }
#define TRACE_STACK_FILE(fp)  { UT_StackTrace tr(fp); tr.doTraceback(); }
#define TRACE_STACK_COND(cond){ UT_StackTrace tr; tr.doCondTraceback(cond); }

class UT_API UT_StackTrace
{
public:
                 explicit UT_StackTrace(FILE *output = stderr);

    void         doTraceback(UTsignalHandlerArg sig_arg,
                             const char *label = 0);
    void         doTraceback(const char *label = 0);

    void         doCondTraceback(const char *symbol,
                                 const char *label = 0);

    void         doTracebackIntoBuffer(UT_WorkBuffer &result,
                                       UTsignalHandlerArg sig_arg,
                                       const char *label = 0);
    void         doTracebackIntoBuffer(UT_WorkBuffer &result,
                                       const char *label = 0);

    void         setShowPC(int state)
                 {
                     UT_IF(myShowPC  = (state != 0);)
                 }
    void         setVerbose(int state)
                 {
                     UT_IF(myVerbose = (state != 0);)
                 }
    // setting the Max stack level  is useful if you only want to 
    // print out a set number of levels of the stack 
    // (i.e. you are trying to find out who is directly calling a 
    // certain method)
    void         setMaxStackLevel(int level)
                 {
                     myMaxStackLevel = level;
                 }
    //
    // Allow global control of the stack tracebacks so that we can
    // selectively enable/disable them in chosen code blocks.
    //
    static void  enableTraceBacks(int state)
                 {
                    UT_IF(ourEnableFlag = (state != 0);)
                 }

    static void  enableCondTrace(const char *symbol, bool enable);


private:
    void         doTracebackIntoBuffer(UT_WorkBuffer &result,
                                       UTsignalHandlerArg *sig_arg,
                                       const char *label);

    FILE            *myFile;
    int              myMaxStackLevel;
    unsigned int     myVerbose:1, myShowPC:1;

    static char      ourEnableFlag;
};

#endif

---