home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Add-Ons / BBEdit / MacBob 1.0ß2 / Source / Exceptions.cp < prev    next >
Encoding:
Text File  |  1995-12-11  |  3.2 KB  |  219 lines  |  [TEXT/KAHL]
  1. /***
  2.   *
  3.   *    Exceptions.cp
  4.   *    Copyright © 1992-1995 by Christopher E. Hyde.  All rights reserved.
  5.   *
  6.   *    Version:    1.07                12/95
  7.   *
  8.   ***/
  9.  
  10. #include "Exceptions.h"
  11.  
  12. #undef    qDebug
  13. #define    qDebug    0
  14. #define    qExtras    0
  15.  
  16. #ifndef qNoExceptionGlobals
  17. FailInfo*    gTopHandler    = nil;            // Pointer to the top level (most recent) handler
  18. short        gFailE        = 0;
  19. long        gFailM        = 0;
  20. #endif
  21.  
  22.  
  23. pascal void
  24. FailMemError (void)
  25. {
  26.     OSErr err = MemError();
  27.  
  28.     if (err != noErr) Fail(err);
  29. }
  30.  
  31.  
  32. pascal void
  33. FailNil (void* p)
  34. {
  35.     if (p == nil) Fail(memFullErr);
  36. }
  37.  
  38.  
  39. #if qExtras
  40. pascal void
  41. FailNilResource (void* r)
  42. {
  43.     if (r == nil) {
  44.         OSErr err = ResError();
  45.         Fail((err != noErr) ? err : resNotFound);    // Fix bug in Resource manager
  46.     }
  47. }
  48.  
  49.  
  50. pascal void
  51. FailOSErr (OSErr err)
  52. {
  53.     if (err != noErr) Fail(err);
  54. }
  55.  
  56.  
  57. pascal void
  58. FailResError (void)
  59. {
  60.     OSErr err = ResError();
  61.  
  62.     if (err != noErr) Fail(err);
  63. }
  64.  
  65.  
  66. pascal void
  67. FailNewMessage (short err, long oldMessage, long newMessage)
  68. {
  69.     if (oldMessage == 0) oldMessage = newMessage;
  70.     Failure(err, oldMessage);
  71. }
  72. #endif
  73.  
  74.  
  75. #if qNoAssembler
  76.  
  77. //extern "C" void    DoRetry        (FailInfo* fi);
  78. //#pragma noreturn(DoRetry)
  79.  
  80. #if qDebug
  81. static void        NoHandler    (void);
  82. #pragma noreturn(NoHandler)
  83. #else
  84. #define    NoHandler()    ExitToShell()
  85. #pragma noreturn(ExitToShell)
  86. #endif
  87.  
  88. extern "C" {
  89.  
  90. #pragma parameter DoFailure(__A1)
  91. pascal void DoFailure (FailInfo* fi) = {
  92.         0x4CD1, 0xDDFC,        // MOVEM.L    (A1),D2-D7/A0/A2-A4/A6/A7
  93.         0x7000,                // MOVEQ        #0,D0
  94.         0x4ED0                // JMP        (A0)
  95.     };
  96. #pragma noreturn(DoFailure)
  97.  
  98. #pragma parameter DoRetry(__A1)
  99. pascal void DoRetry (FailInfo* fi) = {
  100.         0x4CD1, 0xDDFC,        // MOVEM.L    (A1),D2-D7/A0/A2-A4/A6/A7
  101.         0x7001,                // MOVEQ        #1,D0
  102.         0x4ED0                // JMP        (A0)
  103.     };
  104. #pragma noreturn(DoRetry)
  105.  
  106. }
  107.  
  108.  
  109. void
  110. Fail (short err)
  111. {
  112. //    Failure(err, 0);
  113.     gFailE = err;
  114.     gFailM = 0;
  115.     Failure();
  116. }
  117.  
  118.  
  119. #if qExtras
  120. void
  121. Failure (short err, long message)
  122. {
  123.     gFailE = err;
  124.     gFailM = message;
  125.     Failure();
  126. }
  127. #endif
  128.  
  129.  
  130. void
  131. Failure (void)
  132. {
  133.     FailInfo*    fi = gTopHandler;
  134.  
  135.     if (fi /*!= nil*/) {
  136.         gTopHandler = fi->nextInfo;            // Pop the stack first,
  137.         DoFailure(fi);                        // Go execute the failure handler
  138.     } else
  139.         NoHandler();
  140. }
  141.  
  142.  
  143. #if qExtras
  144. pascal bool
  145. HandlerExists (FailInfo* testFi)
  146. {
  147.     for (FailInfo* fi = gTopHandler; fi != nil; fi = fi->nextInfo)
  148.         if (fi == testFi) return true;
  149.     return false;
  150. }
  151.  
  152.  
  153. void
  154. Success (FailInfo* fi)
  155. {
  156.     if (gTopHandler)
  157.         gTopHandler = fi->nextInfo;
  158.     else
  159.         NoHandler();
  160. }
  161. #endif
  162.  
  163.  
  164. void
  165. Success (void)
  166. {
  167. //    Success(gTopHandler);
  168.     if (gTopHandler)
  169.         gTopHandler = gTopHandler->nextInfo;    // Pop the top failure handler
  170. }
  171.  
  172.  
  173. // Pushes a handler back on the stack, resets the error and message to zero, and invokes
  174. // the handler. This has the effect of re-executing the TRY block for the handler.
  175. pascal void
  176. Retry (FailInfo* fi)
  177. {
  178.     gFailE = noErr;
  179.     gFailM = 0;
  180.  
  181.     fi->nextInfo = gTopHandler;
  182.     gTopHandler = fi;
  183.  
  184.     DoRetry(fi);
  185. }
  186.  
  187.  
  188. #if qDebug
  189. // Signals fatal error caused by a call to Failure() or Success(FailInfo*) when the handler stack is empty.
  190. static void
  191. NoHandler (void)
  192. {
  193.     DebugStr("\pFailure stack is empty!");
  194.  
  195.     ExitToShell();
  196. }
  197. #endif
  198.  
  199.  
  200. #endif    // qNoAssembler
  201.  
  202.  
  203. #if qExtras
  204. pascal void
  205. ProgramBreak (ConstStr255Param grievance)
  206. {
  207.     SysBeep(1);
  208.     DebugStr(grievance);
  209. }
  210.  
  211.  
  212. pascal void
  213. ProgramReport (ConstStr255Param grievance, bool brk)
  214. {
  215.     SysBeep(1);
  216.     DebugStr(grievance);
  217. }
  218. #endif
  219.