windows-server-2003/net/sockets/winsock2/ws2_32/inc/trycatch.h

/*++

****COPYRIGHT NOTICE*****

Module Name:

    trycatch.h

Abstract:

    This  module  provides macros to support a lexical-scope exception-handling
    mechanism.  A brief comparison between this mechanism and the C++ exception
    mechanism is as follows:

    macro exception mechamism:

        extremely low run-time overhead

        catches exceptions only in lexical scope

        no value passed to exception handler

        explicitly thrown exceptions only

        exception regions can be nested and named

        usable by older compilers

    C++ exception mechanism:

        handles  all  types  of  exceptions  including  C  exceptions implicity
        thrown.

        catches exceptions thrown in dynamic scope

        involves some setup and teardown run-time overhead

        requires an up-to-date C++ compiler version

    These  macros  are  written  and  used  in  such a fashion that they can be
    transformed back into the C++ exception mechanism if needed.

Author:

    Paul Drews (drewsxpa@ashland.intel.com) 31-October-1995

Notes:

    $Revision:   1.2  $

    $Modtime:   12 Jan 1996 15:09:02  $

Revision History:

    most-recent-revision-date email-name
        description

    31-October-1995 drewsxpa@ashland.intel.com
        created

--*/

#ifndef _TRYCATCH_
#define _TRYCATCH_


// The TRY_START macro starts a guarded region

#define TRY_START(block_label) \
    /* nothing to do */


// The  TRY_THROW  macro  is  used  inside a guarded region to exit the guarded
// region immediately and enter the exception-recovery region.

#define TRY_THROW(block_label) \
    goto catch_##block_label


// The  TRY_CATCH  macro  marks  the  end  of the guarded region and starts the
// beginning  of  the  exception-recovery  region.   If  the TRY_CATCH macro is
// encountered in normal execution, the exception-recovery region is skipped.

#define TRY_CATCH(block_label) \
    goto end_##block_label; \
    catch_##block_label:


// The TRY_END macro marks the end of the exception-recovery region.  Execution
// resumes  here after completing execution of either the guarded region or the
// exception-recovery region.

#define TRY_END(block_label) \
    end_##block_label:



// A typical usage example of these macros is as follows:
//
// char *  buf1 = NULL;
// char *  buf2 = NULL;
// BOOL    return_value;
//
// TRY_START(mem_guard) {
//     buf1 = (char *) malloc(1000);
//     if (buf1 == NULL) {
//         TRY_THROW(mem_guard);
//     }
//     buf2 = (char *) malloc(1000);
//     if (buf2 == NULL) {
//         TRY_THROW(mem_guard);
//     }
//     return_value = TRUE;
// } TRY_CATCH(mem_guard) {
//     if (buf1 != NULL) {
//         free(buf1);
//         buf1 = NULL;
//     }
//     return_value = FALSE;
// } TRY_END(mem_guard);
//
// return return_value;


#endif // _TRYCATCH_