MkErrorC_atl.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define   META_FILE_NAME      "MkErrorC_atl.c"
 
#include  "LibMkKernel_private_atl.h"
 
#define   OT_CLASS            amkrt->AtlMkErrorC
#define   OT_NULL             amkrt->AtlMkErrorC_MK_NULL
#define   OT_CLASS_NAME       "MkErrorC"
 
#define   SELF2HDL(O)         MkErr(VAL2MNG(O))
 
// LNG: class
// -> moved to LibMkKernel_atl.h → OT_MK_RT_S → AtlMkKernelCTT;
 
// META: ObjNew feature: called to return a new or an already existing ATL-SELF-Object
// -> moved to LibMkKernel_atl.h → MkKernelC_ObjNew
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MkErrorC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  SETUP_amkrt(env);
  return AtomMake(obj,OT_CLASS,NULL,NULL,env);
}
 
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(MkErrorC_selfDelete) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  MK(AtomDeleteHard) (OT_MK_CALL selfO);
}
 
// META: called to destroy link from SELF to META
static void NS(MkErrorC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  return MK(AtomUnlink) (OT_MK_CALL selfO);
}
 
#define OT_SETUP_hdl                  SetupHdlFromMetaData_2(MK_ERR)
#define OT_SETUP_hdl__null_allow      SetupHdlFromMetaData__null_allow_2(MK_ERR)
#define OT_SETUP_hdl_destr            SetupHdlFromMetaData__null_allow_2(MK_ERR)
#define OT_SETUP_hdl_constr           SetupHdlConstr(MkErrorC)
#define OT_SETUP_hdl_static_constr    OT_SETUP_hdl_static
#define OT_SETUP_hdl_static           SetupHdlStatic(MkErrorC)
 
#define OT_retObj_CONSTR(x)           OT_retObj_SET(AtomInit(OT_SELF,MkErrorC_X2obj(x),amkrt))
 
// initialize the ATL and META class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (MkErrorCTT == NULL) MkErrorCTT = MkErrorSTT; \
 \
  /* protect against double call */ \
  if (MkErrorCTT->selfCreate == NS(MkErrorC_selfCreate)) return MK_OK; \
 \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MkErrorCTT->selfCreate    = NS(MkErrorC_selfCreate); \
  MkErrorCTT->selfDelete    = NS(MkErrorC_selfDelete); \
  MkErrorCTT->selfUnlink    = NS(MkErrorC_selfUnlink); \
 \
  /* create the ATL-class */ \
  OT_CLASS = AltClassDef(MkErrorCTT,&amkrt->AtlMkErrorC_NS); \
    if (OT_CLASS == NULL) goto error; \
    OT_REF_INCR(OT_CLASS); \
 \
  /* create the ATL static Methods */ \
  check_LNG(AtlUnknownSetup (NS(sOtClassDef),amkrt)) goto error; \
 \
  /* create the ATL instance Methods */ \
  check_LNG(AtlUnknownSetup (NS(sInstanceDef),amkrt)) goto error; \
 \
  /* after class was modified, recompile the class */ \
  RL_init(2, recompile, RL_T(0,RecompileN)); RL_O(1,OT_CLASS) ; \
    int retI = RL_EvalEx(0); \
      if (retI != TCL_OK) return retI; \
 \
  /* define the "NULL" object */ \
  OT_NULL = AtomCreateNULL(OT_CLASS, "::MkErrorC::MK_NULL", (MK_PTR)amkrt); \
    if (OT_NULL == NULL) goto error; \
    OT_REF_INCR(OT_NULL);
/* LABEL-END */
 
/*****************************************************************************/
/*                                                                           */
/*                            D O C                                          */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-DOC - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkErrorC,MkError,sc_,func
#define DEFAULT_doc "MkErrorC [MkErrorC::DEFAULT]"
#define FORMAT_doc "MkErrorC [MkErrorC::FORMAT ?fmtobj:MkObjectC=NULL?]"
#define GetNull_doc "MkErrorC [MkErrorC::GetNull]"
#define HandleResolve_doc "MkErrorC [MkErrorC::HandleResolve netHdl:MK_HDL]"
#define IGNORE_doc "MkErrorC [MkErrorC::IGNORE]"
#define Instances_doc "MkErrorC [MkErrorC::Instances]"
#define PRINT_doc "MkErrorC [MkErrorC::PRINT]"
 
// doc-key: MkErrorC,MkError,oCx,func
#define Dup_doc "MkErrorC [MkErrorC::Dup $srce] (const)"
 
// doc-key: MkErrorC,MkError,oc_,func
#define Catch_doc "MkErrorC [MkErrorC::Catch $err ?exception:errorCode=NULL? ?callfunc:string=\"MK_NULL\"?]"
#define Next_doc "MkErrorC [MkErrorC::Next $err]"
#define NoRaise_doc "MkErrorC [MkErrorC::NoRaise $err]"
#define Prev_doc "MkErrorC [MkErrorC::Prev $err]"
 
// doc-key: MkErrorC,MkError,om_,func
#define AppendC_doc "MkErrorC::AppendC $err message:string"
#define Cleanup_doc "MkErrorC::Cleanup $err ?callfunc:string=\"MK_NULL\"? ?callline:int32=-1?"
#define Copy_doc "MkErrorC::Copy $dest srce:MkErrorC"
#define GetCode_doc "MkErrorE [MkErrorC::GetCode $err] (const)"
#define GetNum_doc "int32 [MkErrorC::GetNum $err] (const)"
#define GetSize_doc "long [MkErrorC::GetSize $err] (const)"
#define GetText_doc "string [MkErrorC::GetText $err] (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define IsABORT_doc "bool [MkErrorC::IsABORT $err] (const)"
#define IsEXIT_doc "bool [MkErrorC::IsEXIT $err]"
#define IsSOCKET_doc "bool [MkErrorC::IsSOCKET $err] (const)"
#define IsTIMEOUT_doc "bool [MkErrorC::IsTIMEOUT $err] (const)"
// skip class-overload: Log → MkObjectLog
#define Println_doc "MkErrorC::Println $err ?msg:string=\"\"? ?callfunc:string=\"MK_NULL\"? ?callline:int32=-1?"
#define Raise_doc "MkErrorC::Raise $err (const)"
#define Reset_doc "MkErrorC::Reset $err ?callfunc:string=\"MK_NULL\"? ?callline:int32=-1? ?force:bool=false?"
#define SetABORT_doc "MkErrorC::SetABORT $err ?detail:string=\"UNKNOWN\"? ?callfunc:string=\"MK_NULL\"?"
#define SetC_doc "MkErrorC::SetC $err message:string ?callfunc:string=\"MK_NULL\"? ?errnum:int32=-1?"
#define SetCONTINUE_doc "MkErrorC::SetCONTINUE $err"
#define SetCode_doc "MkErrorC::SetCode $err code:MkErrorE"
#define SetEXIT_doc "MkErrorC::SetEXIT $err ?callfunc:string=\"MK_NULL\"?"
#define SetSOCKET_doc "MkErrorC::SetSOCKET $err ?detail:string=\"UNKNOWN\"? ?callfunc:string=\"MK_NULL\"?"
#define Stack_doc "MkErrorE [MkErrorC::Stack $err ?callfunc:string=\"MK_NULL\"? ?callfile:string=\"MK_NULL\"? ?callline:int32=-1?]"
#define StackFormat_doc "MkErrorC::StackFormat $err ?callfunc:string=\"MK_NULL\"? ?callfile:string=\"MK_NULL\"? ?callline:int32=-1?"
// skip class-overload: ToString → MkObjectToString
 
// doc-key: MkErrorC,MkPanic,sm_,func
#define PanicC_doc "MkErrorC::PanicC fmtobj:MkObjectC callfunc:string errnum:int32 message:string"
#define PanicDEFAULT_doc "MkErrorC::PanicDEFAULT ?fmtobj:MkObjectC=NULL? ?callfunc:string=\"MK_NULL\"?"
 
// END-DOC - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                            S T A R T                                      */
/*                                                                           */
/*****************************************************************************/
 
// catch ignore MkErrorE
#define MkErrorCatchTmpl(...)   MK(MkExceptionC_Catch)(OT_Prefix_CALL __VA_ARGS__)
 
/*****************************************************************************/
/*                                                                           */
/*                        O B J E C T                                        */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-MkErrorC - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkErrorC,MkErrorC-Class-Export,sc_
 
static OT_ProcRet NS(MkErrorC_HandleResolve) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleResolve_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorHandleResolve (netHdl);
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkErrorC,MkErrorC-Class-Export,om_
 
// skip on class-overload: MkErrorHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkErrorC_HandleGet) (MkErrorC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkErrorC_Class_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-Class-Introspection,oc_
 
static OT_ProcRet NS(MkErrorC_Next) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorNext (hdl);
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_Prev) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorPrev (hdl);
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkErrorC,MkErrorC-Class-Introspection,sc_
 
static OT_ProcRet NS(MkErrorC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorInstances ();
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkErrorC_Class_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-Class-Misc,sc_
 
static OT_ProcRet NS(MkErrorC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorGetNull ();
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkErrorC_Class_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-Get,om_
 
static OT_ProcRet NS(MkErrorC_GetCode) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetCode_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,MkErrorGetCodeI (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_GetNum) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetNum_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkErrorGetNumI (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_GetSize) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetSize_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_LONG(MkErrorGetSizeI (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_GetText) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetText_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkErrorGetTextI (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkErrorC_Get_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-Misc,oc_
 
static OT_ProcRet NS(MkErrorC_Catch) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,2,Catch_doc);
  MK_EXP exception = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_EXP (exception))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MK_ERR retVal = MkErrorCatchTmpl (hdl, exception, callfunc);
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// doc-key: MkErrorC,MkErrorC-Misc,om_
 
static OT_ProcRet NS(MkErrorC_Cleanup) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,2,Cleanup_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 callline = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (callline))
  OT_CHECK_NOARGS;
  if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorCleanup (hdl, callfunc, callline);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// skip on class-overload: MkErrorLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkErrorC_Log) (MkErrorC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MkErrorC_Println) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,Println_doc);
  MK_STRN msg = "";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (msg))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 callline = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (callline))
  OT_CHECK_NOARGS;
  if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorPrintln (hdl, msg, callfunc, callline);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_Reset) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,Reset_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 callline = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (callline))
  MK_BOOL force = false;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (force))
  OT_CHECK_NOARGS;
  if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorC_Check(hdl,MkErrorReset (hdl, callfunc, callline, force));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_Stack) (MkErrorC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_VARARGS(0,3,Stack_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_STRN callfile = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfile))
  MK_I32 callline = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (callline))
  OT_CHECK_NOARGS;
  if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
  if (MkSysStringIsNULL(callfile)) {callfile = OT_GET_CALL_FILE;}
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,MkErrorStack (hdl, callfunc, callfile, callline)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_StackFormat) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,StackFormat_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_STRN callfile = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfile))
  MK_I32 callline = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (callline))
  OT_CHECK_NOARGS;
  if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
  if (MkSysStringIsNULL(callfile)) {callfile = OT_GET_CALL_FILE;}
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorStackFormat (hdl, callfunc, callfile, callline);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// skip on class-overload: MkErrorToString → MkObjectToString
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkErrorC_ToString) (MkErrorC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkErrorC_Misc_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-Raise,oc_
 
static OT_ProcRet NS(MkErrorC_NoRaise) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(NoRaise_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorNoRaise (hdl);
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkErrorC,MkErrorC-Raise,om_
 
static OT_ProcRet NS(MkErrorC_AppendC) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendC_doc);
  MK_STRN message = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (message))
  OT_CHECK_NOARGS;
  MkErrorAppendC (hdl, message);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_Raise) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Raise_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkErrorRaise (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_SetC) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,SetC_doc);
  MK_STRN message = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (message))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 errnum = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (errnum))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorC_Check(hdl,MkErrorSetC (hdl, message, callfunc, errnum));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// doc-key: MkErrorC,MkErrorC-Raise,sm_
 
static OT_ProcRet NS(MkErrorC_PanicC) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(1,4,PanicC_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 errnum = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (errnum))
  MK_STRN message = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (message))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkPanicC (fmtobj, callfunc, errnum, message);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_PanicDEFAULT) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,2,PanicDEFAULT_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkPanicDEFAULT (fmtobj, callfunc);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkErrorC_Raise_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-Signal,om_
 
static OT_ProcRet NS(MkErrorC_IsABORT) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(IsABORT_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkErrorIsABORT (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_IsEXIT) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(IsEXIT_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkErrorIsEXIT (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_IsSOCKET) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(IsSOCKET_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkErrorIsSOCKET (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_IsTIMEOUT) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(IsTIMEOUT_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkErrorIsTIMEOUT (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_SetABORT) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,2,SetABORT_doc);
  MK_STRN detail = "UNKNOWN";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (detail))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorC_Check(hdl,MkErrorSetABORT (hdl, detail, callfunc));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_SetCONTINUE) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SetCONTINUE_doc);
  OT_CHECK_NOARGS;
  MkErrorSetCONTINUE (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_SetCode) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetCode_doc);
  enum MkErrorE code = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkErrorE,code))
  OT_CHECK_NOARGS;
  MkErrorSetCode (hdl, code);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_SetEXIT) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,SetEXIT_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorC_Check(hdl,MkErrorSetEXIT (hdl, callfunc));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_SetSOCKET) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,2,SetSOCKET_doc);
  MK_STRN detail = "UNKNOWN";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (detail))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorC_Check(hdl,MkErrorSetSOCKET (hdl, detail, callfunc));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkErrorC_Signal_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-System,sc_
 
static OT_ProcRet NS(MkErrorC_DEFAULT) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(DEFAULT_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorDEFAULT ();
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_FORMAT) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,1,FORMAT_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorFORMAT (fmtobj);
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_IGNORE) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(IGNORE_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorIGNORE ();
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkErrorC_PRINT) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(PRINT_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorPRINT ();
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkErrorC_System_ATL_API
 
 
// doc-key: MkErrorC,MkErrorC-TOR,oCx
 
static OT_ProcRet NS(MkErrorC_Dup) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Dup_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MkErrorDup (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkErrorC);
    goto error;
  }
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkErrorC,MkErrorC-TOR,om_
 
static OT_ProcRet NS(MkErrorC_Copy) (MkErrorC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Copy_doc);
  MK_ERRN srce = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ERRN (srce,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorCopy (hdl, srce);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkErrorC_TOR_ATL_API
 
// END-MkErrorC - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
static const OtObjProcDefS NS(sOtClassDef)[] = {
  // BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkErrorC,MkError,sc_
  { "::MkErrorC::DEFAULT"       , NS(MkErrorC_DEFAULT)       },
  { "::MkErrorC::FORMAT"        , NS(MkErrorC_FORMAT)        },
  { "::MkErrorC::GetNull"       , NS(MkErrorC_GetNull)       },
  { "::MkErrorC::HandleResolve" , NS(MkErrorC_HandleResolve) },
  { "::MkErrorC::IGNORE"        , NS(MkErrorC_IGNORE)        },
  { "::MkErrorC::Instances"     , NS(MkErrorC_Instances)     },
  { "::MkErrorC::PRINT"         , NS(MkErrorC_PRINT)         },
 
  // doc-key: MkErrorC,MkPanic,sm_
  { "::MkErrorC::PanicC"        , NS(MkErrorC_PanicC)        },
  { "::MkErrorC::PanicDEFAULT"  , NS(MkErrorC_PanicDEFAULT)  },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sInstanceDef)[] = {
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkErrorC,MkError,oCx
  { "::MkErrorC::Dup"           , NS(MkErrorC_Dup)           },
 
  // doc-key: MkErrorC,MkError,oc_
  { "::MkErrorC::Catch"         , NS(MkErrorC_Catch)         },
  { "::MkErrorC::Next"          , NS(MkErrorC_Next)          },
  { "::MkErrorC::NoRaise"       , NS(MkErrorC_NoRaise)       },
  { "::MkErrorC::Prev"          , NS(MkErrorC_Prev)          },
 
  // doc-key: MkErrorC,MkError,om_
  { "::MkErrorC::AppendC"       , NS(MkErrorC_AppendC)       },
  { "::MkErrorC::Cleanup"       , NS(MkErrorC_Cleanup)       },
  { "::MkErrorC::Copy"          , NS(MkErrorC_Copy)          },
  { "::MkErrorC::GetCode"       , NS(MkErrorC_GetCode)       },
  { "::MkErrorC::GetNum"        , NS(MkErrorC_GetNum)        },
  { "::MkErrorC::GetSize"       , NS(MkErrorC_GetSize)       },
  { "::MkErrorC::GetText"       , NS(MkErrorC_GetText)       },
  // skip class-overload: HandleGet → MkObjectHandleGet
  { "::MkErrorC::IsABORT"       , NS(MkErrorC_IsABORT)       },
  { "::MkErrorC::IsEXIT"        , NS(MkErrorC_IsEXIT)        },
  { "::MkErrorC::IsSOCKET"      , NS(MkErrorC_IsSOCKET)      },
  { "::MkErrorC::IsTIMEOUT"     , NS(MkErrorC_IsTIMEOUT)     },
  // skip class-overload: Log → MkObjectLog
  { "::MkErrorC::Println"       , NS(MkErrorC_Println)       },
  { "::MkErrorC::Raise"         , NS(MkErrorC_Raise)         },
  { "::MkErrorC::Reset"         , NS(MkErrorC_Reset)         },
  { "::MkErrorC::SetABORT"      , NS(MkErrorC_SetABORT)      },
  { "::MkErrorC::SetC"          , NS(MkErrorC_SetC)          },
  { "::MkErrorC::SetCONTINUE"   , NS(MkErrorC_SetCONTINUE)   },
  { "::MkErrorC::SetCode"       , NS(MkErrorC_SetCode)       },
  { "::MkErrorC::SetEXIT"       , NS(MkErrorC_SetEXIT)       },
  { "::MkErrorC::SetSOCKET"     , NS(MkErrorC_SetSOCKET)     },
  { "::MkErrorC::Stack"         , NS(MkErrorC_Stack)         },
  { "::MkErrorC::StackFormat"   , NS(MkErrorC_StackFormat)   },
  // skip class-overload: ToString → MkObjectToString
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
 
// script2code.atl MkErrorC_atl MkErrorC.atl
// #include "MkErrorC.h"
 
 
int NS(pMkErrorC_Init) ( OT_MK_ARGS OT_NS_T ns )
{
  ClassInit
 
  MkErrorDefaultC_TT->selfCreate    = NS(MkErrorC_selfCreate);
  MkErrorDefaultC_TT->selfDelete    = NS(MkErrorC_selfDelete);
  MkErrorDefaultC_TT->selfUnlink    = NS(MkErrorC_selfUnlink);
 
  return TCL_OK;
error:
  return TCL_ERROR;
}