可嵌套的C语言异常处理机制

C是一门古老的、面向过程的语言，相对于它的运行高效率，其开发效率是较低的，所以长期以来，C就主要被定位在系统软件的开发上，特别是在现代各种可视化编程环境下，C的应用领域也越来越窄，虽然其原因有很多，但是，相对其它现代高级语言而言，其原始的异常处理功能不能不说是低效开发的主要原因之一，如果有一套较完善的异常功能，再配上一套好的常用功能库，应该能提高其开发效率。

在现代语言中，异常机制包括两个方面，即抛出异常和处理异常。在C语言程序中，异常类型一般都是靠函数的返回值和一些全局变量（如stdio.h的errno变量）来确定的，这大概算是“异常抛出”吧；处理异常最简单的办法就是终止程序，如使用exit、abort函数，虽然还有套较完备的异常处理函数setjmp和longjmp，但是，C的标准库、一般的应用库都没有应用它们，所以我们也只能在自己的开发部分有限地运用一下，而且，很多不太精通C的人，还没法把它们运用好。我在一些C语言书和网上看到了不少用setjmp和longjmp函数开发C异常机制的文章，有些构思还是很好的，但设计得很粗糙，没能达到推广应用的境界。

我也花了几天功夫研究了一番，利用setjmp和longjmp函数，仿造Delphi的异常机制搞了几个“宏”，虽还不那么完美，但已经初具雏形，在我有限的测试中，和Delphi的异常机制完全相似，当然，这里说的“相似”是我测试的较上层的内容，而Delphi的VCL从最低层的代码就与异常紧密结合在一起，异常机制已经是VCL的不可缺少的重要组成部分，这一点C++也没得比（当然内核用VCL的BCB又另当别论）。现将代码发布在这里，望朋友们多提建议来完善它，即使不能达到应用的目的，也可通过这种研究，加深对异常机制的理解。

/** ***********************************************************************
**
*except_c.h*
**
*定义C语言使用的异常类型、函数和宏*
**
*湖北省公安县统计局：maozefa2007.12于辽宁大连*
**
************************************************************************ */

#ifndef__EXCEPT_C_H
#define__EXCEPT_C_H

#include < setjmp.h >

/* 定义全部异常类型，可按需要定义任何异常类型，供ON_EXCEPT宏使用 */
#defineEXCEPT_ALL 0

/** ***********************************************************************
**
*定义异常宏：*
**
*1、Raise(type,msg)：抛出type异常，msg为异常信息*
*2、RaiseMessage(msg)：抛出异常，相当于Raise(EXCEPT_ALL,msg)*
*3、ReRaise()：重新抛出以前的异常*
**
*4、异常响应。对可能出现的异常进行处理(无异常时，处理代码不执行)：*
**
*TRY*
*正常代码*
*ON_EXCEPT(type)*
*可选项。处理type异常的代码，可在EXCEPT前连续使用*
*EXCEPT*
*可选项。所有异常处理代码，相当于ON_EXCEPT(EXCEPT_ALL)*
*END_TRY*
**
*5、异常保护。无论是否出现异常，均执行的保护性质代码，如资源释放：*
**
*TRY*
*正常代码*
*FINALLY*
*保护性质代码*
*END_TRY*
**
*6、套异常可嵌套使用，但不能混用，如：*
**
*TRY*
*代码块1*
*TRY*
*代码块2*
*FINALLY*
*保护性质代码*
*END_TRY*
*EXCEPT*
*异常处理代码*
*END_TRY*
**
************************************************************************ */

#defineTRYexcept_Set();
if ( ! except_SetNum(setjmp( * except_Buf())))
{

#defineRaise(type,msg)except_Raise(type,msg,__FILE__,__LINE__)

#defineRaiseMessage(msg)Raise(EXCEPT_ALL,msg)

#defineReRaise()except_ReRaise()

#defineON_EXCEPT(type)
}
else if (except_On(type))
{

#defineEXCEPTON_EXCEPT(EXCEPT_ALL)

#defineFINALLY}
{

#defineEND_TRY}
except_end();

/* 异常结构 */
typedefstruct__Exception
{
int type; /* 异常类型 */
char * message; /* 消息 */
char * soufile; /* 源文件 */
int lineNum; /* 产生异常的行号 */
}Exception;

// 获取当前异常消息
char * except_Message( void );
// 获取当前异常结构
Exception * except_Exception( void );

// 以下函数为内部使用
void except_Set( void );
void except_Raise( int type, const char * message, char * file, int line);
void except_ReRaise( void );
int except_On( int type);
void except_end( void );
jmp_buf * except_Buf( void );
int except_SetNum( int Num);

#endif /* __EXCEPT_C_H */

#include < malloc.h >
#include < string.h >
#include < stdio.h >
#include < stdlib.h >
#include " except_c.h "

#defineMESSAGE_FORMAT " %s(%d): "

enum {evEnter,evRaise,evExcept = 2 };

typedefstruct__Exception_Event
{
struct__Exception_Event * prev;
jmp_bufeBuf;
int evNum;
Exceptionexception;
}Exception_Event;

static Exception_Event * except_ptr = NULL;
static char * except_msg;
static char except_msg_size = 0 ;

void except_Set( void )
{
Exception_Event * ev;
ev = (Exception_Event * )malloc(sizeof(Exception_Event));
ev -> prev = except_ptr;
except_ptr = ev;
}

void except_Clear( void )
{
Exception_Event * ev;
if (except_ptr)
{
ev = except_ptr;
except_ptr = except_ptr -> prev;
free(ev);
}
}

void except_Raise( int type, const char * message, char * file, int line)
{
int len = 0 ,size;
#ifndefNDEBUG
char buf[ 100 ];
sprintf(buf,MESSAGE_FORMAT,file,line);
len = strlen(buf);
#endif
size = strlen(message) + len + 1 ;
if (except_msg_size < size)
{
if (except_msg_size > 0 )
free(except_msg);
except_msg_size = size;
except_msg = ( char * )malloc(except_msg_size);
}
#ifndefNDEBUG
strcpy(except_msg,buf);
strcat(except_msg,message);
# else
strcpy(except_msg,message);
#endif
if (except_ptr)
{
except_ptr -> exception.type = type;
except_ptr -> exception.message = & except_msg[len];
except_ptr -> exception.soufile = file;
except_ptr -> exception.lineNum = line;
longjmp(except_ptr -> eBuf,evRaise);
}
else
{
fprintf(stderr,except_msg);
abort();
}
}

void except_ReRaise( void )
{
Exceptione;
if (except_ptr)
{
e = except_ptr -> exception;
if (except_ptr -> prev)
{
except_Clear();
except_ptr -> exception = e;
longjmp(except_ptr -> eBuf,evRaise);
}
else
{
fprintf(stderr,except_msg);
abort();
}
}
}

int except_On( int type)
{
if (except_ptr -> evNum == evRaise &&
(type == EXCEPT_ALL || type == except_ptr -> exception.type))
{
except_ptr -> evNum = evExcept;
return 1 ;
}
return 0 ;
}

void except_end( void )
{
if (except_ptr -> evNum == evRaise)
except_ReRaise();
except_Clear();
}

jmp_buf * except_Buf( void )
{
return & except_ptr -> eBuf;
}

char * except_Message( void )
{
return except_msg;
}

Exception * except_Exception( void )
{
return & except_ptr -> exception;
}

int except_SetNum( int Num)
{
except_ptr -> evNum = Num;
return except_ptr -> evNum;
}

有关异常的使用在except_c.h文件中已经说得很清楚了，不再阐述，后面再举例说明。下面简单说该异常机制的原理：

先说说不嵌套的情况，我们知道setjmp和longjmp必须配合使用，首先调用一次setjmp，用一个jmp_buf类型变量（假定a_buf）保存了当前现场，即计算机的各个寄存器状态，此时setjmp返回值为0，如果在程序代码某些地方用同一变量a_buf调用longjmp函数，那么，由a_buf保存的现场得以恢复，计算机将跳转到设置现场变量a_buf的setjmp函数前，导致该函数再次被调用，并返回由longjmp传递的值（依靠该值，我们得以区分约定的异常类型或者出处）；如果在abuf被设置后，又调用setjmp设置了一个b_buf现场，显然，用该现场变量调用longjmp函数，只能恢复到b_buf设置的地方，这样就形成了互不干扰的嵌套异常，假如内层异常机制出现异常，得到处理后，上层异常机制不能捕获到错误，就跳出了这多层异常机制，相当于作了异常相应；如果内层异常机制出现异常，没能够得到适当处理，那么，只需将异常信息传递到上一层异常机制（重新抛出异常），并清除内层异常标志，如此嵌套循环，直到某个异常处理环节进行处理，或者作最后终止程序的处理。

在具体实现时，用一个向上的链表结构Exception_Event的静态变量except_ptr组成异常嵌套的基础，每次调用TRY宏，都重新设置链表尾，碰到END_TRY宏时，如果没有异常发生，或者异常发生后作了处理，那么，清除本层的Exception_Event数据，使链尾指向上一层，如果发生异常没作处理，或者处理后重新抛出异常，那么，END_TRY宏将异常信息向上层移交后，并清除本层数据，使链尾指向上一层。

　　上面说的是设置异常和处理异常的情况，再简单说说抛出异常Raise宏，Raise宏调用了except_Raise函数，函数中，如果Exception_Event结构的静态变量except_ptr不为NULL，也就是设置了异常机制后，将异常信息写到该变量中，否则，显示错误信息后，调用abort终止程序，所以，在自己写的库函数中，可以无顾虑的使用该宏作异常抛出，即使调用库函数的代码没用TRY，Raise也只相当于assert宏而已。

下面给一个演示例子：

// ---------------------------------------------------------------------------

#include < stdio.h >
#include < stdlib.h >
#include " except_c.h "

#pragmahdrstop

// ---------------------------------------------------------------------------

#defineEXCEPT_FILE_IO - 1

void FileCopy( char * Source, char * Dest)
{
FILE * fo, * fi;
int ch;
char s[ 256 ];
printf( " 打开源文件... " );
if ((fi = fopen(Source, " rb " )) == NULL)
Raise(EXCEPT_FILE_IO, " 源文件未找到 " );
TRY
printf( " 建立目标文件... " );
if ((fo = fopen(Dest, " wb " )) == NULL)
Raise(EXCEPT_FILE_IO, " 建立目标文件失败 " );
TRY
printf( " 开始拷贝文件... " );
// RaiseMessage("拷贝文件错误 ");
while ( 1 )
{
ch = fgetc(fi);
if (ch == EOF && ferror(fi))
Raise(EXCEPT_FILE_IO, " 读文件错误 " );
if (feof(fi))
break ;
if (fputc(ch,fo) == EOF && ferror(fo))
Raise(EXCEPT_FILE_IO, " 写文件错误 " );
}
FINALLY
printf( " 关闭目标文件... " );
fclose(fo);
END_TRY
FINALLY
printf( " 关闭源文件... " );
fclose(fi);
END_TRY
}

#pragmaargsused
int main( int argc, char * argv[])
{
TRY
if (argc < 3 )
{
printf( " 程序功能：拷贝文件格式：%s源文件目标文件 " ,argv[ 0 ]);
RaiseMessage( " 程序参数错误！ " );
}
FileCopy(argv[ 1 ],argv[ 2 ]);
ON_EXCEPT(EXCEPT_FILE_IO)
fprintf(stderr, " 处理文件类型错误：%s " ,except_Message());
EXCEPT
fprintf(stderr, " 处理全部错误：%s " ,except_Message());
END_TRY

system( " pause " );
return 0 ;
}
// ---------------------------------------------------------------------------

下面，我们一步步来测试该例子（为了显示结果，FileCopy函数中每个步骤都作了显示）：

1、该控制台例子程序要求带参数运行，实现文件拷贝。在主函数中，有个TRY结构，首先检查程序参数个数，如果小于3，抛出异常，该异常会被下面的EXCEPT宏捕获处理，显示信息为：

处理全部错误：ExceptMain(55)：程序参数错误!

2、给定正确的源文件和目标文件，上面的异常不存在了，主函数调用FileCopy函数，此时运行正常，结果为：

3、修改源文件为错误的路径，FileCopy函数中产生异常，这个异常是在TRY之前抛出的，所以直接被主函数中异常结构中ON_EXCEPT(EXCEPT_FILE_IO)捕获，运行结果为：

4、改回正确的源文件路径，把已经形成的目标文件改为只读属性，这时产生异常如下显示，表示目标文件不能建立，这时已经打开的源文件应该关闭，因此导致源文件关闭的FINALLY宏正确执行了，异常被主函数的TRY结构捕获：

5、取消目标文件只读属性，将例子代码中FileCopy函数中被注释的语句RaiseMessage("拷贝文件错误\n");打开，以模拟产生拷贝过程错误，此时产生异常后，应同时关闭源文件和目标文件，结果，2个FINALLY都正确执行，异常被主函数的TRY结构捕获：

至此，该例子全部测试完毕。该例子实际有3层TRY嵌套，FileCopy函数中是2层TRY...FINALLY异常结构，主函数则是TRY...EXCEPT结构，从测试结果看，完全达到了目的，用Delphi类似的例子运行结果完全一样！

前面已经说了，该异常机制处理自己写的代码应该问题不大，但是对于标准库的错误能捕获吗？我想，有些硬件异常应该是能捕获的，如浮点数错误，下面用个例子演示：

// ---------------------------------------------------------------------------

#include < stdio.h >
#include < stdlib.h >
#include " except_c.h "
#include < signal.h >
#include < float .h >

#pragmahdrstop

// ---------------------------------------------------------------------------

void FPE_Handler( int sig, int num)
{
char err[][ 32 ] =
{
" Interruptonoverflow " ,
" Integerdividebyzero " ,
"" ,
" invalidoperation " ,
"" ,
" dividebyzero " ,
" arithmeticoverflow " ,
" arithmeticunderflow " ,
" precisionloss " ,
" stackoverflow " ,
};
_fpreset();
if (num >= FPE_INTOVFLOW && num <= FPE_STACKFAULT)
Raise(num,err[num - FPE_INTOVFLOW]);
else
Raise(num, " Otherfloatingpointerror " );
}


#pragmaargsused
int main( int argc, char * argv[])
{
float n = 0 ;
TRY
if (signal(SIGFPE,FPE_Handler) == SIG_ERR)
RaiseMessage( " Couldn'tsetSIGFPE " );
n = 2 / n;
ON_EXCEPT(FPE_ZERODIVIDE)
fprintf(stderr, " 处理浮点数被零除错误：%s " ,except_Message());
EXCEPT
fprintf(stderr, " 处理全部错误：%s " ,except_Message());
END_TRY

system( " pause " );
return 0 ;
}
// ---------------------------------------------------------------------------

该例子安装了一个浮点数错误处理过程FPE_Handler，并在过程中使用了Raise抛出异常；主函数中，我们人为的制造了一个浮点数被零除的的错误n = 2 / n（n = 0.0），FPE_Handler函数用Raise抛出了该异常，异常被主函数内TRY结构的ON_EXCEPT(FPE_ZERODIVIDE)捕获并处理，显示为“divide by zero“错误；如果把float改为int，则错误类型不再是FPE_ZERODIVIDE，所以，异常被EXCEPT捕获，显示为“Integer divide by zero”错误；如果不用TRY机制，则程序会立即终止，从而失去处理机会。

本文的异常机制作为一种探讨和学习，无论从构思、设计和代码都不可避免的存在问题，要实用还需要大家的建议，如异常结构类型能否灵活一点；异常抛出时，消息可否提供格式化；其他标准异常怎样捕获和规范定义等，都是需要解决的问题。

本文例子使用BCB2007编译，如有错误和建议请来信：[email protected]