Win32 API Programming with Visual Basic

2017-07-07 02:10:07

Page 130

8. Exception Handling


		As you proceed through this book, running the sample code and experimenting on your own, you will probably encounter a great many General Protection Faults (GPFs). That is only natural. In this chapter, we'll look at how Windows handles system and application errors that occur in Win32 API calls and how you can override its default error handling in your Visual Basic code.


	Thwarting the General Protection Fault


		Before we discuss how to work around GPFs, first consider the following code:

Dim lpDest As Long

Dim lng As Long

lng = 5

CopyMemory ByVal lpDest, ByVal VarPtr(lng), 1


		This code will produce a GPF because I forgot to set the value of the destination address lpDest. so it is simply initialized to 0. But writing to memory location 0 causes a GPF, with the accompanying message shown in Figure 8-1.


		Of course, once the OK button is selected, Windows will terminate the application abruptly. There is no opportunity to recover from recover from such an error, as we can when writing pure VB code. Or is there?


		Here is what is happening. When an exception (another word for error) occurs in a process, Windows looks for an exception handler to handle the exception. When Windows creates a process, it installs a default exception handler for the process,

Page 131

Figure 8-1.

Trying to write to memory location 0


		called UnhandledExceptionFilter. This function is called if the programmer has not installed a replacement exception handler (stay tuned).


		UnhandledExceptionFilter first checks to see if the process being debugged is attached to a debugger. If not, as is the case for the VB programmer, the function will display a nasty error message such as the one in Figure 8-1. Subsequently, if the user selects the Cancel button, Windows will start a debugger for the thread. (By default, this is Visual C++ if it is installed on the user's system.) On the other hand, if the user selects the OK button, the UnhandledExceptionFilter function simply calls ExitProcess to terminate the process in which the thread is running.


	Replacing the Default Exception Handler


		Now to the point. There is a Win32 API function called SetUnhandledExceptionFilter. To quote the documentation:


		The SetUnhandledExceptionFilter function lets an application supersede the top-level exception handler that Win32 places at the top of each thread and process.


		The VB syntax for the SetUnhandledExceptionFilter function is:

Declare Function SetUnhandledExceptionFilter Lib "kernel32" ( _

ByVal lpTopLevelExceptionFilter As Long _

) As Long


		where the parameter lpTopLevelExceptionFilter is the address of the replacement exception handler.


		Thus, we need only to make the call:


		SetUnhandledExceptionFilter AddressOf NewExceptionHandler


		where NewExceptionHandler is a replacement exception handler in a VB standard code module.

Page 132


		The SetUnhandledExceptionFilter function returns the address of the previous exception handler, but we will not need this address. To restore the original default handler, we just call the function with the lpTopLevelExceptionFilter parameter set to 0.


	The Replacement Exception Handler


		The replacement exception handler should have the signature:

Function NewExceptionHandler(ByRef lpExceptionPointers As _

EXCEPTION_POINTERS) As Long


		This function receives the address of an EXCEPTION_POINTERS structure in the parameter lpExceptionPointers. This structure allows the replacement exception handler to get information about the exception. In particular, the structure is defined as follows:

Type EXCEPTION_POINTERS

pExceptionRecord As Long 'pointer to an EXCEPTION_RECORD struct

pContextRecord As Long ' pointer to a CONTEXT struct

End Type


		The second member of this structure is a pointer to a CONTEXT structure that contains information about the state of the machine at the time the exception handler is called (that is, at the time of the exception). This structure reports such things as the state of the CPU registers. However, we will not go into this further, since it is not relevant to our discussion.


		On the other hand, the first member points to a structure defined as follows:

Type EXCEPTION_RECORD

ExceptionCode As Long

ExceptionFlags As Long

pExceptionRecord As Long ' Pointer to an EXCEPTION_RECORD struct

ExceptionAddress As Long

NumberParameters As Long

ExceptionInformation(EXCEPTION_MAXIMUM_PARAMETERS) As Long

End Type


		Let us briefly describe the members of this structure.

ExceptionCode

Gives the code number for the exception. The possible values are shown in Table 8-1.

Table 8-1. Exception Codes
Exception Codes	Value
EXCEPTION_ACCESS_VIOLATION	&HC0000005&
EXCEPTION_ARRAY_BOUNDS_EXCEEDED	&HC0000008C&
EXCEPTION_BREAKPOINT	&H80000003&


		(table continued on next page.)

Page 133


		(table continued from previous page.)

Table 8-1. Exception Codes (continued)
Exception Codes	Value
EXCEPTION_DATATYPE_MISALIGNMENT	&H80000002&
EXCEPTION_FLT_DENORMAL_OPERAND	&HC000008D&
EXCEPTION_FLT_DIVIDE_BY_ZERO	&HC000008E&
EXCEPTION_FLT_INEXACT_RESULT	&HC000008F&
EXCEPTION_FLT_INVALID_OPERATION	&HC0000090&
EXCEPTION_FLT_OVERFLOW	&HC0000091&
EXCEPTION_FLT_STACK_CHECK	&HC00000092&
EXCEPTION_FLT_UNDERFLOW	&H80000093&
EXCEPTION_GUARD_PAGE	&HC0000001&
EXCEPTION_ILLEGAL_INSTRUCTION	&HC000001D&
EXCEPTION_IN_PAGE_ERROR	&HC0000006&
EXCEPTION_INT_DIVIDE_BY_ZERO	&HC0000094&
EXCEPTION_INT_OVERFLOW	&HC0000095&
EXCEPTION_INVALID_DISPOSITION	&HC0000026&
EXCEPTION_INVALID_HANDLE	&HC000008&
EXCEPTION_NONCONTINUABLE_EXCEPTION	&HC00000025&
EXCEPTION_PRIV_INSTRUCTION	&HC0000096&
EXCEPTION_SINGLE_STEP	&H80000004&
EXCEPTION_STACK_OVERFLOW	&HC000000FD&

ExceptionFlags

A value of 0 indicates a continuable exception. A value of EXCEPTION_NONCONTINUABLE_EXCEPTION (&HC0000025&) indicates a noncontinuable exception. Any attempt to continue execution after a noncontinuable exception will generate an exception with exception code EXCEPTION_NONCONTINUABLE_EXCEPTION.

pExceptionRecord

According to the documentation, exceptions may be nested (although the documentation does not say how this can happen). If the pExceptionRecord member is nonzero, then it points to an EXCEPTION_RECORD structure that contains information about a nested exception.

ExceptionAddress

This contains the address of the instruction that caused the exception.

NumberParameters

This value is the number of valid entries in the ExceptionInformation array (coming next).

Page 134

ExceptionInformation

This is used in only one case. When the exception is an access violation (exception code EXCEPTION_ACCESS_VIOLATION), NumberParameters is set to 2, and ExceptionInformation(0) contains a 0 if there was an illegal read attempt and 1 if there was an illegal write attempt. In either case, ExceptionInformation(1) is the memory address at which the read/write attempt was made.


		The documentation states that the replacement exception handler NewExceptionHandler must return one of the following values, which determines the next course of events:

EXCEPTION_EXECUTE_HANDLER

Causes process termination.

EXCEPTION_CONTINUE_EXECUTION

Continues execution at the point of the exception. For us, this will simply mean repeating the exception.

EXCEPTION_CONTINUE_SEARCH

Calls Windows default exception handler.


		However, the documentation is addressed to VC++ programmers. We VB programmers have another trick up our sleeves.


		To understand this trick, let us recall how VB handles errors within its own code. If an error occurs, VB will check the procedure causing the error for an error handler (On Error ). If none is found, then VB will climb the call stack looking for an active error handler. If none is found, then VB issues its own unpleasant error message and terminates the program.


		However, in looking through the call stack, VB will skip over any external procedures that is, any nonVB code. Figure 8-2 shows the call stack when a breakpoint is reached in a replacement exception handler NewExceptionHandler.

Figure 8-2.

The call stack

Page 135


		The first procedure is the Click event shown in Example 8-1, which caused the exception in the kernel32.dll library that exports the CopyMemory function. Thus, the reference to [<Non-Basic Code>] in Figure 8-2 refers to the external CopyMemory function.


		Example 8-1. A Click Event That Causes an Exception

Private Sub cmdRaiseException_Click()

Dim lpDest As Long

Dim lng As Long

On Error GoTo ERR_RaiseException

lng = 5

CopyMemory ByVal lpDest, ByVal VarPtr(lng), 1

MsgBox Recovered from GPF

Exit Sub

ERR_RaiseException:

MsgBox Err.Description

Resume Next

End Sub


		Now, in our replacement exception handler NewExceptionHandler, we do three things:


		We collect information about the exception in a string variable, say sError.


		We deliberately avoid enabling a VB error handler in NewExceptionHandler. In other words, we do not use On Error in this procedure.


		We deliberately place code in NewExceptionHandler to raise a VB error, using the sError value as the description of the error, as in:


		Err.Raise 1000, "NewExceptionHandler", sError


		Now, simply put, if an exception occurs, the call to Err.Raise will cause VB to look for a VB error handler. Since none exists in the offending NewExceptionHandler procedure, VB will search the call stack, skipping over the external code that caused the exception. Hence, in the case shown in Figure 8-2, the error handler in the cmdRaiseException_Click event will fire, thus displaying the description of the exception in a VB message box, as shown in Figure 8-3.


		We now have complete control over what happens next. For instance, in the error-handling code in cmdRaiseException_Click, we call Resume Next to continue execution, but of course there are other possibilities. The point is that the VB application will not terminate abruptly.

Page 136

Figure 8-3.

A VB message box describing the GPF


		Before turning to a complete example, we should mention that this approach to exception handling can be very helpful. However, for the sake of space and clarity of purpose, we will not employ it in the examples in this book.


	A Complete Example


		Example 8-2 shows the code for the NewExceptionHandler replacement exception handler. A complete application is on the accompanying CD. The GetException function below just returns the symbolic constant from Table 8-1 when given the constant's value.


		Example 8-2. The NewExceptionHandler Replacement Exception Handler

Function NewExceptionHandler(ByRef lpExceptionPointers As EXCEPTION_POINTERS) As Long

' No need to return a value since Err.Raise will alter execution flow

Dim er As EXCEPTION_RECORD

Dim sError As String

' Make a copy of the exception record portion

' of the passed-in EXCEPTION_POINTERS structure

CopyMemory er, ByVal lpExceptionPointers.pExceptionRecord, Len(er)

' Set up error description string

sError = GetException(er.ExceptionCode)

' Special treatment for access violation -- get addresses

If sError = EXCEPTION_ACCESS_VIOLATION Then

sError = sError & - Instr @ &H & Hex(er.ExceptionAddress) _

& tried illegally to _

& IIf(er.ExceptionInformation(0) = 0, _

read from address , write to address ) _

& &H & Hex(er.ExceptionInformation(1))

End If

' Check for nested error

If er.pExceptionRecord = 0 Then Exit Do

Page 137


		Example 8-2. The NewExceptionHandler Replacement Exception Handler (continued)

' Nested error exists

' Replace this er by the nested er

CopyMemory er, ByVal er.pExceptionRecord, Len(er)

' New line for next error

sError = sError & vbCrLf

Loop

' Raise an error to go up the call stack, passing the externally

' generated error!

Err.Raise 1000, NewExceptionHandler , sError

End Function

Категории