cii——异常与断言

1. 为什么需要异常和断言

异常：用于release阶段，程序逻辑无问题，但是系统环境异常，导致程序错误。
断言：用于debug阶段，设置程序检查点，方便找到程序bug.

2. c语言与异常

2.1 无异常机制的C语言

C语言本身未提供异常处理，但可以自己实现。

2.2 实现异常处理的基础

可以使用 setjmp 和 longjmp 实现异常处理。

#include <setjmp.h>
#include <stdio.h>

#define EXCEPT_1 1

jmp_buf env;
static void
func()
{
    longjmp(env, 1);
}
int
main(int argc, const char *argv[])
{
    int ret;

    ret = setjmp(env);
    if (ret == 0) {
        func();
    }
    else if (ret == EXCEPT_1) {
        printf("catch except 1\n");
    }

    return 0;
}

执行输出：catch except 1
可见，可以用longjmp的第二个参数表示不同的异常 void longjmp(jmp_buf env, int val);
问题在于env的存储。
由于异常处理和函数调用逻辑相关，所以可以用栈存储env

#include <setjmp.h>
#include <stdio.h>

#define EXCEPT_1 1
#define EXCEPT_2 2

typedef struct except_s {
        jmp_buf env;
        struct except_s *next;
} except_t;

except_t *except_stack_top = NULL;

static void
func2()
{
        jmp_buf *env;

        env = &except_stack_top->env;
        except_stack_top = except_stack_top->next;
        longjmp(*env, EXCEPT_2);
}

static void
func()
{
        int ret;

        except_t e = {.next = NULL};
        if (except_stack_top == NULL) {
                except_stack_top = &e;
        }
        else {
                e.next = except_stack_top;
                except_stack_top = &e;
        }

        ret = setjmp(e.env);
        if (ret == 0) {
                func2();
        }
        else if (ret == EXCEPT_1) {
                printf("catch except 1\n");
        }
        else {
                // 没有找到异常处理，继续向上抛异常
                jmp_buf *env;
                env = &except_stack_top->env;
                except_stack_top = except_stack_top->next;
                longjmp(*env, ret);
        }

}

int
main(int argc, const char *argv[])
{
        int ret;

        except_t e = {.next = NULL};
        if (except_stack_top == NULL) {
                except_stack_top = &e;
        }
        else {
                e.next = except_stack_top;
                except_stack_top = &e;
        }
        ret = setjmp(e.env);
        if (ret == 0) {
                func();
        }
        else if (ret == EXCEPT_1) {
                printf("catch except 1\n");
        }
        else if (ret == EXCEPT_2) {
                printf("catch except 2\n");
        }
        else {
                printf("no catch except\n");
        }

        return 0;
}

用栈的缺点是不能一次找到异常处理点

3 接口设计

3.1 try-excpet

3.1.1 说明

try-except:
TRY
s
EXCEPT(e1)
s1
EXCEPT(e2)
s2
...
EXCEPT(en)
sn
ELSE
s0
END_TRY

TRY之后是可能引发异常的代码，即s。
EXCEPT(e)后是处理异常e的代码，
ELSE后是默认异常处理的代码
END_TRY是卸载异常捕获

如果代码s部分触发异常，则立即中断执行，跳转到对应的 e 处的代码，执行处理异常，
若没有找到对应的异常，则执行ELSE后的s0。最后执行END_TRY卸载异常捕获。

如果代码s没有触发异常，则执行END_TRY卸载异常。

3.1.2 示例

extern except_t allocate_failed;
char *buf;
TRY
buf = allocate(100);
EXCEPT(allocate_failed)
fprintf(stderr, "couldn't allocate the buffer\n");
exit(EXIT_FAILURE);
END_TRY;

3.2 try-finally

3.2.1 说明

TRY
S
FINALLY
S1
END_TRY
当触发异常e时，S执行被中断，执行S1部分，S1执行完成后，再次触发e异常，向上抛。
当没有触发异常，S执行完后，继续执行S1，然后执行END_TRY，后的代码

相当于
TRY
S
ELSE
S1
RERAISE;
END_TRY;
S1

所以：无论触发异常，都会执行S1
try-finally的目的是，当触发异常时给客户程序一个机会进行清理。

3.2.3 示例

FILE *fp = fopen();
char *buf;
TRY
buf = allocate(100);
...
FINALLY
fclose(fp);
END_TRY;

4. 实现

except.h

#ifndef EXCEPT_INCLUDED
#define EXCEPT_INCLUDED
#include <setjmp.h>
#define T Except_T
typedef struct T {
        char *reason;
} T;
typedef struct Except_Frame Except_Frame;
struct Except_Frame {
        Except_Frame *prev;
        jmp_buf env;
        const char *file;
        int line;
        const T *exception;
};
enum { Except_entered=0, Except_raised,
       Except_handled,   Except_finalized };
#ifdef WIN32
__declspec(thread)
#endif
extern Except_Frame *Except_stack;
extern const Except_T Assert_Failed;
void Except_raise(const T *e, const char *file,int line);
#define RAISE(e) Except_raise(&(e), __FILE__, __LINE__)
#define RERAISE Except_raise(Except_frame.exception, \
        Except_frame.file, Except_frame.line)
#define RETURN switch (Except_stack = Except_stack->prev,0) default: return
#define TRY do { \
        volatile int Except_flag; \
        Except_Frame Except_frame; \
        Except_frame.prev = Except_stack; \
        Except_stack = &Except_frame;  \
        Except_flag = setjmp(Except_frame.env); \
        if (Except_flag == Except_entered) {
#define EXCEPT(e) \
                if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
        } else if (Except_frame.exception == &(e)) { \
                Except_flag = Except_handled;
#define ELSE \
                if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
        } else { \
                Except_flag = Except_handled;
#define FINALLY \
                if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
        } { \
                if (Except_flag == Except_entered) \
                        Except_flag = Except_finalized;
#define END_TRY \
                if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
                } if (Except_flag == Except_raised) RERAISE; \
} while (0)
#undef T
#endif

4.2 excpet.c

#include <stdlib.h>
#include <stdio.h>
#include "assert.h"
#include "except.h"
#define T Except_T
#ifdef WIN32
__declspec(thread)
#endif
Except_Frame *Except_stack = NULL;
void Except_raise(const T *e, const char *file,
        int line) {
        Except_Frame *p = Except_stack;
        assert(e);
        if (p == NULL) {
                fprintf(stderr, "Uncaught exception");
                if (e->reason)
                        fprintf(stderr, " %s", e->reason);
                else
                        fprintf(stderr, " at 0x%p", e);
                if (file && line > 0)
                        fprintf(stderr, " raised at %s:%d\n", file, line);
                fprintf(stderr, "aborting...\n");
                fflush(stderr);
                abort();
        }
        p->exception = e;
        p->file = file;
        p->line = line;
        Except_stack = Except_stack->prev;
        longjmp(p->env, Except_raised);
}

5. 注意

如果S（被检查异常部分）改变了自动变量的值，如果异常导致转向某个处理程序Sn，或END_TRY之后的代码，
那么该修改可能无效。如
int i = 0;
TRY
i++;
RAISE(e);
EXCEPT(e)
;
END_TRY
printf("%d", i);
可能输出0，也可能输出1。这取决于setjmp和longjmp的实现。
S中改变的局部变量必须声明未volatile。如
volatile int i = 0;

6. 断言

6.1 说明

断言通常定义如下

#ifdef NDEBUG
#define assert(e) (void 0)
#else
extern void assert(int e);
#define assert(e) ((void) ( (e) || \
            fprintf(stderr, "%s:%d: Assertion failed: %s\n", \
                __FILE__, (int)__LINE__, #e), abort(), 0))
#endif

这里希望将断言为真，抛出异常。

6.2 实现

6.2.1 assert.h

#undef assert
#ifdef NDEBUG
#define assert(e) ((void)0)
#else
#include "except.h"
extern void assert(int e);
#define assert(e) ((void)((e)||(RAISE(Assert_Failed),0)))
#endif

6.2.2 assert.c

#include "assert.h"
const Except_T Assert_Failed = { "Assertion failed" };
void (assert)(int e) {
        assert(e);
}