This routine removes the cleanup handler routine established by
    the matching call to pthread_cleanup_push() from the calling
    thread's cleanup handler stack, then executes it if the value
    specified in this routine's execute argument is nonzero.

    A cleanup handler routine can be used to clean up from a block
    of code whether exited by normal completion, cancelation, or the
    raising (or reraising) of an exception. The routine is popped
    from the calling thread's cleanup handler stack and is called
    with the arg argument (see the description for pthread_cleanup_
    push()) when any of the following actions occur:

    o  The thread calls pthread_cleanup_pop() and specifies a nonzero
       value for the execute argument.

    o  The thread calls pthread_exit().

    o  The thread is canceled.

    o  An exception is raised and is caught when the Threads Library
       unwinds the calling thread's stack to the lexical scope of the
       pthread_cleanup_push() and pthread_cleanup_pop()  pair.

    This routine and pthread_cleanup_push() are implemented as
    macros and must appear as statements and in pairs within the
    same lexical scope. You can think of the pthread_cleanup_push()
    macro as expanding to a string whose first character is a left
    brace ({) and pthread_cleanup_pop() as expanding to a string
    containing the corresponding right brace (}). This routine and
    pthread_cleanup_push() are implemented as exceptions, and may not
    work in a C++ environment. (See <REFERENCE>(exceptions_chap) for
    more information.)