Win32

SEH

일반적으로 SEH는 C 프로그래머들에게만 유용한다.
Windows 예외 처리부나 종료 처리부는 C++ 객체 인스턴스의 소멸자를 호출하지 않는다.

__leave
RaiseException()

EXCEPTION_EXECUTE_HANDLER // 예외 블럭을 실행한다.
EXCEPTION_CONTINUE_SEARCH
EXCEPTION_CONTINUE_EXECUTION

GetExceptionCode()
GetExceptionInformation ()

AbnormalTermination()

VOID ReportException (LPCTSTR UserMessage, DWORD ExceptionCode)
           
/* Report as a non-fatal error.
    Print the system error message only if the message is non-null. */
{   
    if (lstrlen (UserMessage) > 0)
        ReportError (UserMessage, 0, TRUE);
            /* If fatal, raise an exception. */

    if (ExceptionCode != 0)
        RaiseException (
            (0x0FFFFFFF & ExceptionCode) | 0xE0000000, 0, 0, NULL);
   
    return;
}

int _tmain (DWORD argc, LPTSTR argv [])
{
    ...
    if (argc <= 1)
        ReportError (_T ("Usage: toupper files"), 1, FALSE);
                    /* Process all files on the command line. */
    for (iFile = 1; iFile < argc; iFile++) __try { /* Exception block */
        ...
        __try { /* Inner try-finally block */
            ... ReportException (_T("..."), 1) ...
        } __finally { /* File handles are always closed */
            ...
        }
    } /* End of main file processing loop and try block. */
    /* This exception handler applies to the loop body */

    __except (EXCEPTION_EXECUTE_HANDLER) {
        _tprintf (_T("Error occured processing file %s\n"), argv[iFile]);
        ...
    }
    _tprintf (_T("All files converted, except as noted above\n"));
    return 0;
}

static DWORD Filter (LPEXCEPTION_POINTERS pExP, LPDWORD ECatgry)

/*    Categorize the exception and decide whether to continue execution or
    execute the handler or to continue the search for a handler that
    can process this exception type. The exception category is only used
    by the exception handler. */
{
    DWORD ExCode;
    DWORD_PTR ReadWrite, VirtAddr;
    ExCode = pExP->ExceptionRecord->ExceptionCode;
    _tprintf (_T ("Filter. ExCode: %x\n"), ExCode);
    if ((0x20000000 & ExCode) != 0) {
                /* User Exception. */
        *ECatgry = 10;
        return EXCEPTION_EXECUTE_HANDLER;
    }

    switch (ExCode) {
        case EXCEPTION_ACCESS_VIOLATION:
                /* Determine whether it was a read or write
                    and give the virtual address. */
            ReadWrite =
                pExP->ExceptionRecord->ExceptionInformation [0];
            VirtAddr =
                pExP->ExceptionRecord->ExceptionInformation [1];
            _tprintf
                ("Access Violation. Read/Write: %d. Address: %x\n",
                ReadWrite, VirtAddr);
            *ECatgry = 1;
            return EXCEPTION_EXECUTE_HANDLER;
        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
            *ECatgry = 1;
            return EXCEPTION_EXECUTE_HANDLER;
                    /* Integer arithmetic exception. Halt execution. */
        case EXCEPTION_INT_DIVIDE_BY_ZERO:
        case EXCEPTION_INT_OVERFLOW:
            *ECatgry = 2;
            return EXCEPTION_EXECUTE_HANDLER;
                    /* Float exception. Attempt to continue execution. */
                    /* Return the maximum floating value. */
        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
        case EXCEPTION_FLT_OVERFLOW:
            _tprintf (_T ("Flt Exception - Large result.\n"));
            *ECatgry = 3;
            _clearfp();
            return (DWORD) EXCEPTION_EXECUTE_HANDLER;
        case EXCEPTION_FLT_DENORMAL_OPERAND:
        case EXCEPTION_FLT_INEXACT_RESULT:
        case EXCEPTION_FLT_INVALID_OPERATION:
        case EXCEPTION_FLT_STACK_CHECK:
            _tprintf (_T ("Flt Exception - Unknown result.\n"));
            *ECatgry = 3;
            return (DWORD) EXCEPTION_CONTINUE_EXECUTION;
                    /* Return the minimum floating value. */
        case EXCEPTION_FLT_UNDERFLOW:
            _tprintf (_T ("Flt Exception - Small result.\n"));
            *ECatgry = 3;
            return (DWORD) EXCEPTION_CONTINUE_EXECUTION;
        case EXCEPTION_DATATYPE_MISALIGNMENT:
            *ECatgry = 4;
            return EXCEPTION_CONTINUE_SEARCH;
        case STATUS_NONCONTINUABLE_EXCEPTION:
            *ECatgry = 5;
            return EXCEPTION_EXECUTE_HANDLER;
        case EXCEPTION_ILLEGAL_INSTRUCTION:
        case EXCEPTION_PRIV_INSTRUCTION:
            *ECatgry = 6;
            return EXCEPTION_EXECUTE_HANDLER;
        case STATUS_NO_MEMORY:
            *ECatgry = 7;
            return EXCEPTION_EXECUTE_HANDLER;
        default:
            *ECatgry = 0;
            return EXCEPTION_CONTINUE_SEARCH;
    }
}

int _tmain (int argc, LPTSTR argv [])
{
    DWORD ECatgry;
    BOOL Done = FALSE;
...
    while (!Done) __try {
        ...
        __try { /* Try-Except block. */
            ... __leave ...
        } /* End of inner __try. */

        __except (Filter (GetExceptionInformation (), &ECatgry)){
            switch (ECatgry) {
            case 0:    _tprintf (_T ("Unknown exception.\n"));
                break;
            case 1:    _tprintf (_T ("Memory ref exception.\n"));
                break;
            case 2:    _tprintf (_T ("Integer arithmetic exception.\n"));
                break;
            case 3:   
                 _tprintf (_T ("floating-point exception.\n"));
                break;
            case 10: _tprintf (_T ("User generated exception.\n"));
                break;
            default: _tprintf (_T ("Unknown exception.\n"));
                break;
            }
            _tprintf (_T ("End of handler.\n"));
        } /* End of inner __try __except block. */

    } /* End of outer __try __finally */
    __finally {
        BOOL AbTerm;
        AbTerm = AbnormalTermination();
        _tprintf (_T ("Abnormal Termination?: %d\n"), !AbTerm);
     }
    return 0;
}

벡터식 예외 처리(vectored exception handling)

AddVectoredExceptionHandler()
RemoveVectoredExceptionHandler()

콘솔 제어 처리부(console control handler)

신호는 프로세스 전체에 적용되지만, 예외는 예외가 발생한 코드가 실행되는 스레드에만 적용된다.

처리부 루틴은 하나의 독립적인 스레드로 수행된다. 프로그램 자체는 그냥 보통의 흐름대로 수행된다.
예외들을 발생하지 않는 외부적 사건들에 대해서도 반응할 수 있다.

SetConsoleCtrlHandler()
GenerateConsoleCtrlEvent()

volatile static BOOL Exit = FALSE;

BOOL WINAPI Handler (DWORD CntrlEvent)
{
    Exit = TRUE;

    switch (CntrlEvent) {
        /* The signal timing will determine if you see the second handler message */
        case CTRL_C_EVENT:
            _tprintf (_T ("Ctrl-c received by handler. Leaving in 10 seconds\n"));
            Sleep (4000); /* Decrease this time to get a different effect */
            _tprintf (_T ("Leaving handler in 6 seconds.\n"));
            Sleep (6000);  /* Also try decreasing this time */
            return TRUE; /* TRUE indicates that the signal was handled. */
        case CTRL_CLOSE_EVENT:
            _tprintf (_T ("Leaving the handler in 10 seconds.\n"));
            Sleep (4000); /* Decrease this time to get a different effect */
            _tprintf (_T ("Leaving handler in 6 seconds.\n"));
            Sleep (6000);  /* Also try decreasing this time */
            return TRUE; /* Try returning FALSE. Any difference? */
        default:
            _tprintf (_T ("Event: %d. Leaving in 10 seconds\n"), CntrlEvent);
            Sleep (4000); /* Decrease this time to get a different effect */
            _tprintf (_T ("Leaving handler in 6 seconds.\n"));
            Sleep (6000);  /* Also try decreasing this time */
            return TRUE; /* TRUE indicates that the signal was handled. */
    }
}

int main(int argc, char* argv[])
{
// {
        /* Add an event handler. */
    if (!SetConsoleCtrlHandler (Handler, TRUE))
        ReportError (_T ("Error setting event handler"), 1, TRUE);
   
    while (!Exit) { /* This flag is detected right after a beep, before a handler exits */
        Sleep (4750); /* Beep every 5 seconds; allowing 250 ms of beep time. */
        Beep (1000 /* Frequency */, 250 /* Duration */);
    }
    _tprintf (_T ("Stopping the main program as requested.\n"));
// }
//    printf("Hello World!\n");
    return 0;
}