/**************************************************************** * Copyright 2001, 2010 Fidelity Information Services, Inc * * * * This source code contains the intellectual property * * of its copyright holder(s), and is made available * * under a license. If you do not know the terms of * * the license, please stop and do not read further. * * * ****************************************************************/ #ifndef ERROR_TRAP_H #define ERROR_TRAP_H #define IS_ETRAP (err_act == &dollar_etrap.str) #define DOLLAR_ECODE_MAXINDEX 32 /* maximum of 32 ecodes in $ECODE */ #define DOLLAR_STACK_MAXINDEX 256 /* maximum of 256 levels will be stored for $STACK(level) */ #define DOLLAR_ECODE_ALLOC (1 << 15) /* 32K chunk memory malloced for $ECODE */ #define DOLLAR_STACK_ALLOC (1 << 15) /* 32K chunk memory malloced for $STACK(level) */ #define STACK_ZTRAP_EXPLICIT_NULL -1 /* used to indicate an explicit SET $ZTRAP = "" */ typedef void (*error_ret_fnptr)(void); typedef struct dollar_ecode { mstr ecode_str; } dollar_ecode_struct; typedef struct dollar_stack /* contents of a single $STACK(level) entry */ { mstr mode_str; /* $STACK(level) */ dollar_ecode_struct *ecode_ptr; /* $STACK(level,"ECODE") */ mstr mcode_str; /* $STACK(level,"MCODE") */ mstr place_str; /* $STACK(level,"PLACE") */ } dollar_stack_struct; typedef enum stack_mode { DOLLAR_STACK_INVALID, DOLLAR_STACK_ECODE, /* $STACK(level,"ECODE") */ DOLLAR_STACK_PLACE, /* $STACK(level,"PLACE") */ DOLLAR_STACK_MCODE, /* $STACK(level,"MCODE") */ DOLLAR_STACK_MODE /* $STACK(level) i.e. how this frame got created */ } stack_mode_t; typedef struct { char *begin; /* beginning of malloced memory holding the complete $ECODE */ char *end; /* pointer to where next $ECODE can be added */ char *top; /* allocated end of malloced memory holding the complete $ECODE */ dollar_ecode_struct *array; /* array of DOLLAR_ECODE_MAXINDEX dollar_ecode_struct structures */ uint4 index; /* current count of number of filled structures in array */ int4 error_last_ecode; /* last error code number */ unsigned char *error_last_b_line; /* ptr to beginning of line where error occurred */ struct stack_frame_struct *first_ecode_error_frame; /* "frame_pointer" at the time of adding the first ECODE */ unsigned char *error_rtn_addr; /* CODE_ADDRESS(ERROR_RTN) */ unsigned char *error_rtn_ctxt; /* GTM_CONTEXT(ERROR_RTN) */ error_ret_fnptr error_return_addr; /* CODE_ADDRESS(ERROR_RETURN) */ } dollar_ecode_type; typedef struct { char *begin; /* beginning of malloced memory holding all $STACK(level) detail */ char *end; /* pointer to where next $STACK(level) detail can be added */ char *top; /* allocated end of malloced memory holding all $STACK(level) detail */ dollar_stack_struct *array; /* array of DOLLAR_STACK_MAXINDEX dollar_stack_struct structures */ uint4 index; /* current count of number of filled structures in array */ boolean_t incomplete; /* TRUE if we were not able to fit in all $STACK info */ } dollar_stack_type; /* reset all $ECODE related variables to correspond to $ECODE = NULL state */ #define NULLIFY_DOLLAR_ECODE \ { \ GBLREF dollar_ecode_type dollar_ecode; \ GBLREF dollar_stack_type dollar_stack; \ \ dollar_ecode.end = dollar_ecode.begin; \ dollar_ecode.index = 0; \ dollar_stack.end = dollar_stack.begin; \ dollar_stack.index = 0; \ dollar_stack.incomplete = FALSE; \ dollar_ecode.first_ecode_error_frame = NULL; \ } /* nullify "error_frame" */ #define NULLIFY_ERROR_FRAME \ { \ GBLREF stack_frame *error_frame; \ \ error_frame = NULL; \ } /* Set "error_frame" to point to "frame_pointer" and mark it as an error frame type. This is an indication that * whenever we unwind back to this frame, we need to transfer control to error_rtn_addr/ctxt (taken care of by getframe). */ #define SET_ERROR_FRAME(fp) \ { \ GBLREF stack_frame *error_frame; \ \ fp->flags |= SFF_ETRAP_ERR; \ error_frame = fp; \ } /* invoke the function error_return() if the necessity of error-rethrow is detected */ #define INVOKE_ERROR_RET_IF_NEEDED \ { \ GBLREF dollar_ecode_type dollar_ecode; \ GBLREF stack_frame *error_frame; \ \ if (NULL != error_frame) \ { \ if (error_frame == frame_pointer) \ { \ if (dollar_ecode.index) /* non-zero implies non-NULL $ECODE */ \ { /* this is an error frame and $ECODE is non-NULL during QUIT out of this frame. \ * rethrow the error at lower level */ \ (*dollar_ecode.error_return_addr)(); \ /* We dont expect the above call to return in Unix since we either rethrow \ * the error or do a MUM_TSTART which unwinds the C-stack. But in VMS, we dont \ * do the latter so it is possible if the current frame is of type SFT_DM that \ * we dont rethrow and dont do a MUM_TSTART as well. Assert accordingly. \ */ \ UNIX_ONLY(assert(FALSE);) /* this should not return */ \ VMS_ONLY(assert(SFT_DM & frame_pointer->type);) \ } else \ { \ assert(FALSE); \ NULLIFY_ERROR_FRAME; /* don't know how we reached here. reset it in PRO */ \ } \ } else if (error_frame < frame_pointer) \ { \ assert(FALSE); \ NULLIFY_ERROR_FRAME; /* don't know how we reached here. reset it in PRO */ \ } \ } \ } void ecode_init(void); void ecode_get(int level, mval *result); /* return $ECODE (if "level" < 0) or $STACK(level,"ECODE") in "result" */ void ecode_set(int errnum); /* convert "errnum" to error-string and call ecode_add() */ boolean_t ecode_add(mstr *str); /* add "str" to $ECODE */ void error_return(void); #ifdef VMS void error_return_vms(void); #endif void get_dollar_stack_info(int level, stack_mode_t mode, mval *result); void get_frame_creation_info(int level, int cur_zlevel, mval *result); void get_frame_place_mcode(int level, stack_mode_t mode, int cur_zlevel, mval *result); #endif /* ERROR_TRAP_H */