hg/stx-libbasic: comparison Exception.st

equal deleted inserted replaced

-:ee6d4213b9df
+:cc55b9f5b47e
 "
 Instances of Exception are passed to a Signal handling block as argument.
 The handler block may perform various actions by sending corresponding messages
 to the exception object. The following actions are possible:
-reject          - dont handle this signal;
+	reject          - dont handle this signal;
-another handler will be searched for,
+			  another handler will be searched for,
-upper in the calling hierarchy
+			  upper in the calling hierarchy
-proceed         - return from the Signal>>raise, with nil as value
+	proceed         - return from the Signal>>raise, with nil as value
-proceedWith:val - same, but return val from Signal>>raise
+	proceedWith:val - same, but return val from Signal>>raise
-return          - return from the Signal>>handle:do:, with nil as value
+	return          - return from the Signal>>handle:do:, with nil as value
-returnWith:val  - same, but return val from Signal>>handle:do:
+	returnWith:val  - same, but return val from Signal>>handle:do:
-(this is also the handlers default,
+			  (this is also the handlers default,
-if it falls through; taking the handlerBlocks value
+			   if it falls through; taking the handlerBlocks value
-as return value)
+			   as return value)
-restart         - restart the Signal>>handle:do:, after repairing
+	restart         - restart the Signal>>handle:do:, after repairing
 Via the Exception object, the handler can also query the state of execution:
 where the Signal was raised, where the handler is, the signal which caused
 the error and the errorString passed when the signal was raised. Also, an optional
 parameter can be passed - the use is signal specific.:
 [instance variables:]
-signal           <Signal>     the signal which caused the exception
+	signal           <Signal>     the signal which caused the exception
-parameter        <Object>     a parameter (if any) which was passed when raising
+	parameter        <Object>     a parameter (if any) which was passed when raising
-the signal (only if raised with #raiseWith:aParameter)
+				      the signal (only if raised with #raiseWith:aParameter)
-errorString      <String>     an errorString
+	errorString      <String>     an errorString
-(usually the signals own errorString, but sometimes
+				      (usually the signals own errorString, but sometimes
-changed explicitely in #raiseWith:errorString:)
+				       changed explicitely in #raiseWith:errorString:)
-suspendedContext <Context>    the context in which the raise occured
+	suspendedContext <Context>    the context in which the raise occured
-handlerContext   <Context>    the context of the handler (if any)
+	handlerContext   <Context>    the context of the handler (if any)
-resumeBlock      <Block>      private to the exception; needed to perform resume action
+	resumeBlock      <Block>      private to the exception; needed to perform resume action
-rejectBlock      <Block>      private to the exception; needed to perform reject action
+	rejectBlock      <Block>      private to the exception; needed to perform reject action
 In case of an unhandled signal raise, Exceptions EmergenyHandler will be evaluated.
 The default emergeny handler will enter the debugger.
 For applications, which do not want Debuggers to come up, other handlers are
 possible.
 For example, to get the typical C++ behavior, use:
-Exception emergencyHandler:[:ex | Smalltalk exitWithCoreDump]
+	Exception emergencyHandler:[:ex | Smalltalk exitWithCoreDump]
 [Class variables:]
-EmergencyHandler <Block>    this block is evaluated, if no handler was defined
+	EmergencyHandler <Block>    this block is evaluated, if no handler was defined
-for a signal (i.e. this one is responsible for the
+				    for a signal (i.e. this one is responsible for the
-unhandled exception debugger).
+				    unhandled exception debugger).
-Having this being a block allows to globally catch
+				    Having this being a block allows to globally catch
-these errors - even when no enclosing handler-scope
+				    these errors - even when no enclosing handler-scope
-around the erronous code exists.
+				    around the erronous code exists.
-(as the catch/through does).
+				    (as the catch/through does).
-RecursiveExceptionSignal
+	RecursiveExceptionSignal
-<Signal>   raised when within a handler for some signal,
+			 <Signal>   raised when within a handler for some signal,
-the same signal is raised again.
+				    the same signal is raised again.
 [see also:]
-Signal  SignalSet QuerySignal
+	Signal  SignalSet QuerySignal
-Context Block
+	Context Block
-Object DebugView
+	Object DebugView
-(``Exception handling and signals'': programming/exceptions.html)
+	(``Exception handling and signals'': programming/exceptions.html)
 [author:]
-Claus Gittinger
+	Claus Gittinger
 "
 !
 examples
 "
 Some commonly used (useful) emergency handlers are provided in the
 'useful handlers' section; try them to learn more
 (especially, the mailingHandler is fun).
 Define a handler:
-[exBegin]
+								[exBegin]
-Exception emergencyHandler:(Exception abortingEmergencyHandler)
+	Exception emergencyHandler:(Exception abortingEmergencyHandler)
-[exEnd]
+								[exEnd]
 try some exception (for demonstration, in some other process):
-[exBegin]
+								[exBegin]
-[
+	[
-#(1 2 3) at:4
+	    #(1 2 3) at:4
-] fork.
+	] fork.
-[exEnd]
+								[exEnd]
 cleanup:
-[exBegin]
+								[exBegin]
-Exception emergencyHandler:nil
+	Exception emergencyHandler:nil
-[exEnd]
+								[exEnd]
 A handler which dumps information to a file (watch the file 'errorTrace.stx'):
-[exBegin]
+								[exBegin]
-Exception emergencyHandler:(Exception dumpingEmergencyHandler)
+	Exception emergencyHandler:(Exception dumpingEmergencyHandler)
-[exEnd]
+								[exEnd]
 A handler which sends you mail:
-[exBegin]
+								[exBegin]
-Exception emergencyHandler:(Exception mailingEmergencyHandler)
+	Exception emergencyHandler:(Exception mailingEmergencyHandler)
-[exEnd]
+								[exEnd]
 "
 ! !
 !Exception class methodsFor:'initialization'!
 "
 set it up, when called the first time
 "
 EmergencyHandler isNil ifTrue:[
-EmergencyHandler := [:ex |
+	EmergencyHandler := [:ex |
-"
+	    "
-sending it to the signal allows per-signal specific
+	     sending it to the signal allows per-signal specific
-debuggers to be implemented in the future
+	     debuggers to be implemented in the future
-(for example, segv in primitive code could show things
+	     (for example, segv in primitive code could show things
-on the C-level ..)
+	      on the C-level ..)
-"
+	    "
-(ex signal) enterDebuggerWith:ex message:(ex errorString).
+	    (ex signal) enterDebuggerWith:ex message:(ex errorString).
-]
+	]
 ].
 ^ EmergencyHandler
 "Modified: 15.1.1997 / 20:50:37 / cg"
 "ST-80 behavior of first showing a notifier:
 (I prefer to get right into the debugger, though)
 Exception
-emergencyHandler:
+	emergencyHandler:
-[:ex | self errorNotify:ex errorString ]
+	    [:ex | self errorNotify:ex errorString ]
 "
 "ST-X behavior of going right into the debugger:
 Exception
-emergencyHandler:nil
+	emergencyHandler:nil
 "
 "automatically aborting current operation, on error:
 (may be useful for end-user apps; make certain,
 you have abortSignal handlers at appropriate places)
 Exception
-emergencyHandler:
+	emergencyHandler:
-[:ex | Object abortSignal raise. ex return. ]
+	    [:ex | Object abortSignal raise. ex return. ]
 "
 "finally, traditional language system behavior; dump core ;-)
 Exception
-emergencyHandler:
+	emergencyHandler:
-[:ex | Smalltalk exitWithCoreDump. ]
+	    [:ex | Smalltalk exitWithCoreDump. ]
 "
 "Modified: 15.1.1997 / 20:49:06 / cg"
 ! !
 "return a block (usable as an emergency handler),
 which aborts after showing a warnBox.
 This is useful for endUser applications"
 ^ [:ex | self warn:'Error: ' , ex errorString.
-AbortSignal raise
+	     AbortSignal raise
 ]
 "test with (try a few halts or CTRL-C's):
 Exception emergencyHandler:(Exception abortingEmergencyHandler)
 "
 This is useful, for endUser application, which are still being
 debugged (i.e. the programmers may have a look at the traceFile
 from time to time).
 Notice:
-The code below is just an example; you may want to change the
+	 The code below is just an example; you may want to change the
-name of the error-file in your application
+	 name of the error-file in your application
-(but please: copy the code; do not modify here)"
+	 (but please: copy the code; do not modify here)"
 ^ [:ex |
-|str printedException|
+	     |str printedException|
-ex signal == Signal noHandlerSignal ifTrue:[
+	     ex signal == Signal noHandlerSignal ifTrue:[
-printedException := ex parameter.
+		printedException := ex parameter.
-] ifFalse:[
+	     ] ifFalse:[
-printedException := ex
+		printedException := ex
-].
+	     ].
-"/ user interruption is handled specially:
+	     "/ user interruption is handled specially:
-"/ allow user to choose between proceeding or aborting
+	     "/ allow user to choose between proceeding or aborting
-"/ but never dump that information to the file.
+	     "/ but never dump that information to the file.
-printedException signal == Object userInterruptSignal ifTrue:[
+	     printedException signal == Object userInterruptSignal ifTrue:[
-(self confirm:'abort current action ?') ifTrue:[
+		  (self confirm:'abort current action ?') ifTrue:[
-AbortSignal raise
+		      AbortSignal raise
-].
+		  ].
-ex proceed
+		  ex proceed
-].
+	     ].
-"/
+	     "/
-"/ dump it to 'errorTrace.stx'
+	     "/ dump it to 'errorTrace.stx'
-"/
+	     "/
-str := 'errorTrace.stx' asFilename appendingWriteStream.
+	     str := 'errorTrace.stx' asFilename appendingWriteStream.
-str nextPutLine:('******************************* '
+	     str nextPutLine:('******************************* '
-, AbsoluteTime now printString
+			      , AbsoluteTime now printString
-, ' *******************************').
+			      , ' *******************************').
-str cr.
+	     str cr.
-str nextPutLine:('** Error: ' , printedException errorString).
+	     str nextPutLine:('** Error: ' , printedException errorString).
-str nextPutLine:('** Signal: ' , printedException signal printString).
+	     str nextPutLine:('** Signal: ' , printedException signal printString).
-str nextPutLine:('** Parameter: ' , printedException parameter printString).
+	     str nextPutLine:('** Parameter: ' , printedException parameter printString).
-str nextPutLine:('** Process: ' , Processor activeProcess printString).
+	     str nextPutLine:('** Process: ' , Processor activeProcess printString).
-str nextPutLine:('** Backtrace:').
+	     str nextPutLine:('** Backtrace:').
-str cr.
+	     str cr.
-printedException suspendedContext fullPrintAllOn:str.
+	     printedException suspendedContext fullPrintAllOn:str.
-str cr.
+	     str cr.
-str cr.
+	     str cr.
-str close.
+	     str close.
-self warn:printedException errorString.
+	     self warn:printedException errorString.
-AbortSignal raise
+	     AbortSignal raise
 ]
 "test with (try a few halts or CTRL-C's):
 Exception emergencyHandler:(Exception dumpingEmergencyHandler)
 "
 which shows a warnBox and optionally mails a stackBacktrace to a maintainer.
 This is useful, for endUser application, which are still being
 debugged (i.e. the programmers may have a look at the errors).
 Notice: the stuff here is a demonstration only; it should be modified
-for your particular environment ...
+	     for your particular environment ...
-... but please: copy the code and modify there;
+	     ... but please: copy the code and modify there;
-leave the stuff below as it is."
+	     leave the stuff below as it is."
 ^ [:ex |
-|str printedException doMail emergencyMailReceiver pipe|
+	    |str printedException doMail emergencyMailReceiver pipe|
-ex signal == Signal noHandlerSignal ifTrue:[
+	    ex signal == Signal noHandlerSignal ifTrue:[
-printedException := ex parameter.
+	       printedException := ex parameter.
-] ifFalse:[
+	    ] ifFalse:[
-printedException := ex
+	       printedException := ex
-].
+	    ].
-"/ user interruption is handled specially:
+	     "/ user interruption is handled specially:
-"/ allow user to choose between proceeding or aborting
+	     "/ allow user to choose between proceeding or aborting
-"/ but never dump that information to the file.
+	     "/ but never dump that information to the file.
-printedException signal == Object userInterruptSignal ifTrue:[
+	     printedException signal == Object userInterruptSignal ifTrue:[
-(self confirm:'abort current action ?') ifTrue:[
+		  (self confirm:'abort current action ?') ifTrue:[
-AbortSignal raise
+		      AbortSignal raise
-].
+		  ].
-ex proceed
+		  ex proceed
-].
+	     ].
-"/ somehow get the name of the guy to receive the mail
+	    "/ somehow get the name of the guy to receive the mail
-"/ you have to implement that yourself.
+	    "/ you have to implement that yourself.
-"/ emergencyMailReceiver := OneOfYourClass getEmergencyMailReceiver.
+	    "/ emergencyMailReceiver := OneOfYourClass getEmergencyMailReceiver.
-emergencyMailReceiver := OperatingSystem getLoginName.
+	    emergencyMailReceiver := OperatingSystem getLoginName.
-emergencyMailReceiver isNil ifTrue:[
+	    emergencyMailReceiver isNil ifTrue:[
-self warn:(printedException errorString
+		self warn:(printedException errorString
-, '\\No mailing to service people possible.') withCRs.
+			   , '\\No mailing to service people possible.') withCRs.
-doMail := false.
+		doMail := false.
-] ifFalse:[
+	    ] ifFalse:[
-doMail := self confirm:(printedException errorString
+		doMail := self confirm:(printedException errorString
-, '\\Mail error information to the service people ('
+					, '\\Mail error information to the service people ('
-, emergencyMailReceiver , ') ?') withCRs
+					, emergencyMailReceiver , ') ?') withCRs
-].
+	    ].
-doMail ifTrue:[
+	    doMail ifTrue:[
-str := '' writeStream.
+		str := '' writeStream.
-str nextPutLine:('Error notification from '
+		str nextPutLine:('Error notification from '
-, OperatingSystem getLoginName
+				, OperatingSystem getLoginName
-, '@'
+				, '@'
-, OperatingSystem getHostName).
+				, OperatingSystem getHostName).
-str cr.
+		str cr.
-str nextPutLine:('Time: ' , AbsoluteTime now printString).
+		str nextPutLine:('Time: ' , AbsoluteTime now printString).
-str nextPutLine:('Error: ', printedException errorString).
+		str nextPutLine:('Error: ', printedException errorString).
-str nextPutLine:('Signal: ', printedException signal printString).
+		str nextPutLine:('Signal: ', printedException signal printString).
-str nextPutLine:('Parameter: ', printedException parameter printString).
+		str nextPutLine:('Parameter: ', printedException parameter printString).
-str nextPutLine:('Process: ', Processor activeProcess printString).
+		str nextPutLine:('Process: ', Processor activeProcess printString).
-str nextPutLine:'Backtrace:'.
+		str nextPutLine:'Backtrace:'.
-str cr.
+		str cr.
-printedException suspendedContext fullPrintAllOn:str.
+		printedException suspendedContext fullPrintAllOn:str.
-str cr;cr.
+		str cr;cr.
-str close.
+		str close.
-pipe := PipeStream
+		pipe := PipeStream
-writingTo:'mail ', emergencyMailReceiver.
+			    writingTo:'mail ', emergencyMailReceiver.
-pipe notNil ifTrue:[
+		pipe notNil ifTrue:[
-pipe nextPutLine:'Subject: automatic error report'.
+		    pipe nextPutLine:'Subject: automatic error report'.
-pipe nextPutAll:str contents.
+		    pipe nextPutAll:str contents.
-pipe cr.
+		    pipe cr.
-pipe close.
+		    pipe close.
-]
+		]
-].
+	     ].
-AbortSignal raise
+	     AbortSignal raise
 ]
 "test with (try a few halts or CTRL-C's):
 Exception emergencyHandler:(Exception mailingEmergencyHandler)
 "
 ATTENTION: the code below depends on being called by #raise or
 #raiseRequest for proper operation (it skips the sending context)."
 |con block noHandlerSignal any msg sel conArg1
 theSignal c ex1 activeHandlers inHandler rejected
-lastHandler h|
+lastHandler h raiseReceiver|
 con := thisContext sender.  "the raise/raiseRequest-context"
 con := con sender.          "the signal raise context"
 theSignal := con receiver.
 theSignal isSignal ifFalse:[
-self halt:'unexpected non-Signal in calling context'.
+	self halt:'unexpected non-Signal in calling context'.
 ].
 "/ 'search handler for: ' print. theSignal displayString printCR.
 inHandler := false.
 "/ from within a handler (which would lead to re-executing the
 "/ same handler)
 "/ the code below collects active handlers ...
 [c notNil] whileTrue:[
-sel := c selector.
+	c := c findContextWithSelector:#doRaise or:nil.
-sel == #doRaise ifTrue:[
+	c notNil ifTrue:[
-ex1 := c receiver.
-ex1 species == self species ifTrue:[
+	    ex1 := c receiver.
-c := c sender.
+	    ((ex1 class == self class)
-(c notNil and:[c receiver == ex1]) ifTrue:[
+	    or:[ex1 species == self species]) ifTrue:[
-c := c sender.
+		c := c sender.
-c notNil ifTrue:[
+		(c notNil and:[c receiver == ex1]) ifTrue:[
-"/ the common case (really ?) first
+		    c := c sender.
-(c receiver == theSignal) ifTrue:[
+		    c notNil ifTrue:[
-(c selector startsWith:'raise') ifTrue:[
-h := ex1 handlerContext.
+			"/ the common case (really ?) first
-h notNil ifTrue:[
+			((raiseReceiver := c receiver) == theSignal) ifTrue:[
-activeHandlers isNil ifTrue:[
+			    (c selector startsWith:'raise') ifTrue:[
-activeHandlers := OrderedCollection new
+				h := ex1 handlerContext.
-].
+				h notNil ifTrue:[
+				    activeHandlers isNil ifTrue:[
-lastHandler := h.
+					activeHandlers := OrderedCollection new
-activeHandlers add:lastHandler.
+				    ].
-inHandler := true.
-c := lastHandler.
+				    lastHandler := h.
-"/ 'skip over active handler: ' print. c displayString printCR.
+				    activeHandlers add:lastHandler.
-]
+				    inHandler := true.
-]
+				    c := lastHandler.
-] ifFalse:[
+				]
-c receiver isSignal ifTrue:[
+			    ]
-(c selector startsWith:'raise') ifTrue:[
+			] ifFalse:[
-h := ex1 handlerContext.
+			    raiseReceiver isSignal ifTrue:[
-h notNil ifTrue:[
+				(c selector startsWith:'raise') ifTrue:[
-(h receiver accepts:theSignal) ifTrue:[
+				    h := ex1 handlerContext.
+				    h notNil ifTrue:[
-activeHandlers isNil ifTrue:[
+					(h receiver accepts:theSignal) ifTrue:[
-activeHandlers := OrderedCollection new
-].
+					    activeHandlers isNil ifTrue:[
-lastHandler := h.
+						activeHandlers := OrderedCollection new
-activeHandlers add:lastHandler.
+					    ].
-inHandler := true.
+					    lastHandler := h.
-c := lastHandler.
+					    activeHandlers add:lastHandler.
-"/ 'skip2 over active handler: ' print. h displayString printCR.
+					    inHandler := true.
-]
+					    c := lastHandler.
-]
+					]
-]
+				    ]
-]
+				]
-]
+			    ]
-]
+			]
-]
+		    ]
-].
+		]
-].
+	    ].
-c := c sender.
+	    c := c sender.
+	]
 ].
+"/ now, start searching for a handler,
+"/ start search above the last active handler
 lastHandler notNil ifTrue:[
-"/        'skip over last active handler: ' print. lastHandler displayString printCR.
+	con := lastHandler sender.
-con := lastHandler sender.
 ].
 any := false.
 [con notNil] whileTrue:[
-con isBlockContext ifFalse:[
+	con isBlockContext ifFalse:[
-"/ new behavior:
+	    sel := con selector.
-(activeHandlers notNil
-and:[activeHandlers includesIdentical:con]) ifTrue:[
+	    ((sel == #'handle:do:')
-'skip activeHandler: ' print. con displayString printCR.
+	    or:[((sel == #'handle:from:do:')
+		and:[(con argAt:2) == originator])]) ifTrue:[
-] ifFalse:[
-sel := con selector.
+		"/ new behavior:
+		(activeHandlers notNil
-((sel == #'handle:do:')
+		 and:[activeHandlers includesIdentical:con]) ifTrue:[
-or:[((sel == #'handle:from:do:')
+		    'skip activeHandler: ' print. con displayString printCR.
-and:[(con argAt:2) == originator])]) ifTrue:[
-"
+		] ifFalse:[
-if this is the Signal>>handle:do: context
+		    "
-or a SignalSet>>handle:do: context with self in it,
+		     if this is the Signal>>handle:do: context
-call the handler
+		     or a SignalSet>>handle:do: context with self in it,
-"
+		     call the handler
-(con receiver accepts:signal) ifTrue:[
+		    "
-"call the handler"
+		    (con receiver accepts:signal) ifTrue:[
+			"call the handler"
-conArg1 := con argAt:1.
+			conArg1 := con argAt:1.
-handlerContext := con.
-any := true.
+			handlerContext := con.
+			any := true.
-self doCallHandler:conArg1.
+			self doCallHandler:conArg1.
-"if the handler rejects, we arrive here"
-"continue search for another handler"
+			"if the handler rejects, we arrive here"
-rejected := true.
+			"continue search for another handler"
-].
+			rejected := true.
-]
+		    ].
-]
+		]
-].
+	    ]
-con := con sender
+	].
+	con := con sender
 ].
 activeHandlers := nil.
-"/    (inHandler "and:[rejected ~~ true]") ifTrue:[
-"/        "
-"/         mhmh - an error while in a handler
-"/         here, we do not fall back to the noHandlerSignal/staticHandler
-"/         (makes debugging easier)
-"/
-"/         Should we ?
-"/        "
-"/        ((signal == RecursiveExceptionSignal)
-"/        or:[RecursiveExceptionSignal isNil]) ifTrue:[
-"/            "
-"/             ... either while handling RecursiveExceptionSignal
-"/             or at startup when RecursiveExceptionSignal is not yet
-"/             created -
-"/             - go immediately into the debugger.
-"/            "
-"/            ^ self enterDebuggerWith:self
-"/                             message:'recursive signal raise'
-"/        ].
-"/        ^ RecursiveExceptionSignal
-"/            raiseRequestWith:self
-"/                 errorString:('recursive signal raise: (' , errorString , ')')
-"/    ].
 "
 we arrive here, if either no handler was found, or none of the
 handlers did a return (i.e. every handler rejected or fell through).
 "
 "
 try per signal handler
 "
 (block := signal handlerBlock) isNil ifTrue:[
-"/
+	"/
-"/ if its a querySignal, ignore it
+	"/ if its a querySignal, ignore it
-"/
+	"/
-signal isQuerySignal ifTrue:[^ nil].
+	signal isQuerySignal ifTrue:[^ nil].
-"/
+	"/
-"/ if it is not the NoHandlerSignal, raise it ...
+	"/ if it is not the NoHandlerSignal, raise it ...
-"/ passing the receiver as parameter.
+	"/ passing the receiver as parameter.
-"/
+	"/
-signal ~~ (noHandlerSignal := Signal noHandlerSignal) ifTrue:[
+	signal ~~ (noHandlerSignal := Signal noHandlerSignal) ifTrue:[
-noHandlerSignal notNil ifTrue:[
+	    noHandlerSignal notNil ifTrue:[
-any ifTrue:[
+		any ifTrue:[
-msg := 'unhandled (rejected)'
+		    msg := 'unhandled (rejected)'
-] ifFalse:[
+		] ifFalse:[
-msg := 'unhandled'
+		    msg := 'unhandled'
-].
+		].
-msg := msg , ' exception: (' , errorString , ')'.
+		msg := msg , ' exception: (' , errorString , ')'.
-^ noHandlerSignal
+		^ noHandlerSignal
-raiseRequestWith:self
+		      raiseRequestWith:self
-errorString:msg
+			   errorString:msg
-in:self suspendedContext
+				    in:self suspendedContext
-].
+	    ].
-"/
+	    "/
-"/ mhmh - an error during early startup; noHandlerSignal is
+	    "/ mhmh - an error during early startup; noHandlerSignal is
-"/ not yet defined.
+	    "/ not yet defined.
-"/
+	    "/
-^ MiniDebugger enterWithMessage:errorString
+	    ^ MiniDebugger enterWithMessage:errorString
-].
+	].
-"
+	"
-mhmh - smells like trouble - there is no handler and
+	 mhmh - smells like trouble - there is no handler and
-no per-signal handler block.
+	 no per-signal handler block.
-Look for either a per-process emergencyHandlerBlock
+	 Look for either a per-process emergencyHandlerBlock
-or the global emergencyHandler (from Exception) ...
+	 or the global emergencyHandler (from Exception) ...
-"
+	"
-Processor notNil ifTrue:[
+	Processor notNil ifTrue:[
-"care for signal during startup (Processor not yet created)"
+	    "care for signal during startup (Processor not yet created)"
-block := Processor activeProcess emergencySignalHandler.
+	    block := Processor activeProcess emergencySignalHandler.
-].
+	].
-block isNil ifTrue:[
+	block isNil ifTrue:[
-block := Exception emergencyHandler.
+	    block := Exception emergencyHandler.
-block isNil ifTrue:[
+	    block isNil ifTrue:[
-"care for error during startup (Exception not yet initialized)"
+		"care for error during startup (Exception not yet initialized)"
-^ MiniDebugger enterWithMessage:errorString
+		^ MiniDebugger enterWithMessage:errorString
-].
+	    ].
-].
+	].
 ].
 "... and call it"
 ^ block value:self.
 "Created: 12.5.1996 / 15:09:39 / cg"
 !
 raise
 "actually raise a non-proceedable exception.
 CAVEAT:
-For now, in ST/X all signals are proceedable."
+	 For now, in ST/X all signals are proceedable."
 resumeBlock := [:value | ^ value].
 ^ self doRaise
 "Modified: 12.5.1996 / 15:09:47 / cg"
 ! !
 !Exception class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/Exception.st,v 1.45 1997-01-18 18:37:26 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/Exception.st,v 1.46 1997-01-20 11:52:22 cg Exp $'
 ! !
 Exception initialize!

changeset 2208	cc55b9f5b47e
parent 2204	0ec2bd49dd82
child 2219	0e7ba134fa8d