Structured exception handling
Exceptions can be initiated by hardware or software, and can occur anywhere in your code. Structured exception handling provides a single mechanism for the handling of exceptions.
The execution of certain instruction sequences can result in exceptions that are initiated by hardware. For example, an access violation is generated by the hardware when a process attempts to read from or write to a virtual address to which it does not have the appropriate access.
Conceptually we set up a protected code block enclosed in a __try { } __except() { } expression. If execution of the code in the protected block provokes an exception, the filter expression in the __except() expression will be executed. This code should return one of the following values:

All this values, and the other definitions mentioned in this manual are in the standard header file <seh.h>. Include this file in any code that uses structured exception handling.

Within the context of the filter expression you can use several functions that can help you get more information about what happened.
The function
            unsigned int GetExceptionCode(void);
returns the code for the current exception. The function
            EXCEPTION_POINTERS *GetExceptionInformation(void);
will return a pointer to a global EXCEPTION_POINTERS structure. That structure contains a pointer to an exception record where a wealth of information is available to know what happened.

This structure is defined as follows:

typedef struct _EXCEPTION_POINTERS {
    PEXCEPTION_RECORD ExceptionRecord;
    PCONTEXT ContextRecord;
} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;

This structure contains just two pointers, one to an exception record, and the other to a CONTEXT record with the state of the machine at the point of the exception. The run time of lcc-win32 arranges for securing this information in a static area at each exception. Note that this information is meaningful if (and only if) an exception is active. At the next exception the static area will be overwritten with new information from the new exception. If you want to preserve the data you should copy it somewhere else.

In the EXCEPTION_RECORD structure we find:

typedef struct _EXCEPTION_RECORD {
  DWORD ExceptionCode;
  DWORD ExceptionFlags; // Can be either zero (continuable exception), or EXCEPTION_NONCONTINUABLE.
  struct _EXCEPTION_RECORD* ExceptionRecord;
  PVOID ExceptionAddress; // Machine address of instruction that faulted
  DWORD NumberParameters; // This two parameters are used by the RaiseException() function.
  ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
} EXCEPTION_RECORD, *PEXCEPTION_RECORD;

ExceptionCode:

 Example:

#include <seh.h>

#include <stdio.h>

int main(void) {

	char *p = NULL;

	int code;

 	__try {

		*p = 0;

	}

	__except(code = GetExceptionCode(),EXCEPTION_EXECUTE_HANDLER) {

		printf("Caught exception %#x\n",code);

	}
  }

This will produce

Caught exception 0xC0000005