home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / VCL_Source / Source / RTL / rtlinc / xxdbg.h < prev   
C/C++ Source or Header  |  2000-02-01  |  6KB  |  208 lines
  1. /*
  2.  *      C/C++ Run Time Library - Version 10.0
  3.  *
  4.  *      Copyright (c) 1993, 2000 by Inprise Corporation
  5.  *      All Rights Reserved.
  6.  *
  7.  */
  8.  
  9. /* $Revision:   9.0  $ */
  10.  
  11.     //
  12.     // An instance of the following struct is embedded in the RTL of an
  13.     // .EXE or .DLL for the purposes of communicating, with a debugger,
  14.     // run-time exceptions.
  15.     //
  16.     // This structure can be found by locating "__DebuggerHookData" in
  17.     // the resident names table, which contains its address.
  18.     //
  19.  
  20. #ifdef    DIABLO
  21.  
  22. struct DebuggerData
  23. {
  24.         //
  25.         // The debugger can scan memory for the following magic numbers,
  26.         // and then grab the address of the hook function.  These also
  27.     // serve as version numbers.
  28.         //
  29.     
  30.     unsigned long    magic1;
  31.     unsigned long    zero;
  32.     unsigned long    magic2;
  33.  
  34.         //
  35.         // The debugger sets a breakpoint at the code this points to, thus
  36.         // gaining control over the child when stuff happens.
  37.         //
  38.     
  39.     void * p_hook_fcn;
  40.  
  41.         //
  42.         // The following member is modified by a debugger so as to
  43.         // tell the run time that it is running under the control of
  44.     // a debugger so it can inform the debugger of C++ exception
  45.         // related events.
  46.         //
  47.     
  48.     unsigned long debugger_watching;
  49.  
  50.     //
  51.     // The following members are the "parameters" to the hook
  52.     // function.  The debugger reads them to determine which kind
  53.     // of C++ exception event happened.
  54.     //
  55.  
  56.         //
  57.         // EventKind describes what kind of C++ exception event has
  58.         // ocurred.  The values have the following meaning:
  59.         //
  60.     
  61.         //
  62.     // EventNull :
  63.     //
  64.     //    Null operation, nothing to do
  65.     //
  66.  
  67.     
  68.     //
  69.     // Throw, catch and destructor events:
  70.     //
  71.     // The following events are generated when certains exception
  72.     // related events occur in the RTL:
  73.     //
  74.     //        
  75.     // EventThrow :
  76.     //
  77.     //    A throw HAS ocurred. Addr points to the instruction which would
  78.     //    have been executed if it hadn't happened.  Name points to the
  79.     //    name of the exception thrown.  Cookie contains the cookie for
  80.     //    this exception.  Msg may contain a pointer to a message
  81.     //    associated with this throw (Pascal will do this). Usually this
  82.     //    event accompanies events describing
  83.     //    the change of the exception stack, which should occur before
  84.     //    EventThrow is generated.
  85.     //
  86.     //
  87.     // EventCatch :
  88.     //
  89.     //    A Catch is ABOUT to happen.  Addr points to the first instruction
  90.     //    of the catch.  Cookie contains the cookie for this exception.
  91.     //
  92.     // EventDestructor :
  93.     //
  94.     //    A destructor is ABOUT to be called because of stack unwinding.
  95.     //    Addr points to the first instruction of the destructor.
  96.     //
  97.  
  98.  
  99.     //
  100.     // The following are specific to C++, describing when the termineted,
  101.     // or unexpected functions are called.
  102.     //
  103.     //
  104.     // EventUnexpected :
  105.     //
  106.     //    The unexpected function is about to be called.  Addr points to
  107.     //    its address.
  108.     //
  109.     // EventTerminated :
  110.     //
  111.     //    The terminated function is about to be called.  Addr points to
  112.     //    its address.
  113.     //
  114.  
  115.  
  116.     //
  117.     // Pending exception stack events:
  118.     //
  119.     //      EventListLast
  120.         //      EventListMore
  121.         //      EventListEmpty
  122.     //
  123.     // These events describe how RTL-maintained stack of
  124.     // pending exceptions looks.  Every time this stack is changed,
  125.     // the RTL notifies the debugger via these events.  The
  126.     // debugger assumes that upon startup, the list is empty, thus
  127.     // the RTL need not notifiy the debugger of this at start up.
  128.     // Every time the list changes, the entire list is re-described
  129.     // to the debugger.  There are three significant ways to describe
  130.         // the new list:
  131.     //
  132.     //   1) If the list has become empty, a single event of kind
  133.     //      EventListEmpty is generated.
  134.     //
  135.     //   2) If the list contains a single element, a single event
  136.     //      of kind EventListLast is generated.
  137.     //
  138.     //   3) If the list contains more than 1 elements N, then N - 1
  139.     //      events of kind EventListMore is generated, followed by
  140.     //      a single event of kind EventListLast.  The first event
  141.     //      described the top of the stack (the most recent exception
  142.     //      pending).
  143.     //
  144.     // For EventListLast and EventListMore, the following members
  145.     // contain information about the element in the list:
  146.     //
  147.     //    name : contains the name of the exception being thrown/raised
  148.     //
  149.     //  cookie : contains an opaque handle representing the element in
  150.     //           the list.  This should remain constant for elements in
  151.         //           the stack which are unchanged between stack changes.
  152.     //
  153.     //    addr : contains a pointer to the object being thrown/raised.
  154.     //           This should not be confused with the cookie, which is
  155.     //           usually a pointer to the RTL's internal data structure
  156.     //           representing the element on it's stack.
  157.     //
  158.     //
  159.  
  160.     
  161.         enum EventKind { EventNull, EventThrow, EventCatch, EventDestructor,
  162.                      EventUnexpected, EventTerminated,
  163.                      EventExcept, EventFinally,
  164.                      EventFilter,
  165.                      EventListLast, EventListMore, EventListEmpty,
  166.              EventRawExceptionStart, EventRawExceptionFinish };
  167.     
  168.     EventKind kind;
  169.     
  170.     unsigned long    addr;
  171.     void *        objectAddr;
  172.     unsigned long    cookie;
  173.  
  174.         //
  175.         // Strings are not neccesarily null terminated.
  176.         //
  177.     
  178.     unsigned long    name_len;
  179.     char *        name;
  180.  
  181.     unsigned long    msg_len;
  182.     char *        msg;
  183.     
  184.         //
  185.         // The following is used for "raw" exceptions only
  186.         //
  187.     
  188.     unsigned long    exception_num; // non C++ exceptions only
  189.  
  190.     void *        reserved[16];
  191. };
  192.  
  193. #endif
  194.  
  195. #ifdef    PRONTODEBUGGER
  196. enum    XXdebuggerNotification
  197. {
  198.     XXDNdtor       = 0,
  199.     XXDNthrow       = 1,
  200.     XXDNrawException   = 2,
  201.     XXDNcatch       = 3,
  202.     XXDNterminated       = 4,
  203.     XXDNunexpected       = 5,
  204.     XXDNcatchTerminate = 6,
  205. };
  206. #endif
  207.  
  208.