MkErrorC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
/*****************************************************************************/
/*                                                                           */
/*                                context                                    */
/*                                                                           */
/*****************************************************************************/
 
#define MkErrorCatchTmpl(hd,...)     MkExceptionC::Catch(static_cast<MK_MNG>(hd),__VA_ARGS__)
 
namespace ccmkkernel {
 
/*
  inline MK_PTR MkErrorC::MkErrorC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
    return new MkErrorC(obj);
  }
*/
 
  inline MkErrorC* MK_DECL MkErrorC::FORMAT (MK_OBJ const fmtobj) {
    MK_ERR retVal = MkErrorFORMAT (fmtobj);
    if (retVal == NULL) {
      throw MkConstructorNullExceptionC("MkErrorC::FORMAT");
    }
    MkRtSetup_XN(retVal);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL retVal);
  }
 
  //   BEGIN-MkErrorC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
  // doc-key: MkErrorC,MkErrorC-Class-Export,sc_
 
  inline MkErrorC* MkErrorC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    MK_ERR __retVal__L = MkErrorHandleResolve(netHdl);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkErrorC,MkErrorC-Class-Export,om_
 
  // skip class-overload: HandleGet = MkErrorHandleGet → MkObjectHandleGet
 
  // MkErrorC_Class_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-Class-Introspection,oc_
 
  inline MkErrorC* MkErrorC::Next ()  {
    MK_UNUSED auto err = getERR();
    MK_ERR __retVal__L = MkErrorNext(err);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkErrorC::Prev ()  {
    MK_UNUSED auto err = getERR();
    MK_ERR __retVal__L = MkErrorPrev(err);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkErrorC,MkErrorC-Class-Introspection,sc_
 
  inline MkErrorC* MkErrorC::Instances ()  {
    MkRtSetup_NULL;
    MK_ERR __retVal__L = MkErrorInstances();
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkErrorC_Class_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-Class-Misc,sc_
 
  inline MkErrorC* MkErrorC::GetNull ()  {
    MkRtSetup_NULL;
    MK_ERR __retVal__L = MkErrorGetNull();
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkErrorC_Class_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-Get,om_
 
  inline MkErrorE MkErrorC::GetCode () const {
    MK_UNUSED auto err = getERRN();
    enum MkErrorE errVal = MkErrorGetCodeI(err);
    return errVal;
  }
 
  inline MK_I32 MkErrorC::GetNum () const {
    MK_UNUSED auto err = getERRN();
    MK_I32 __retVal__L = MkErrorGetNumI(err);
    return __retVal__L;
  }
 
  inline MK_SIZE MkErrorC::GetSize () const {
    MK_UNUSED auto err = getERRN();
    MK_SIZE __retVal__L = MkErrorGetSizeI(err);
    return __retVal__L;
  }
 
  inline MK_STRN MkErrorC::GetText () const {
    MK_UNUSED auto err = getERRN();
    MK_STRN __retVal__L = MkErrorGetTextI(err);
    return __retVal__L;
  }
 
  // MkErrorC_Get_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-Misc,oc_
 
  inline MkErrorC* MkErrorC::Catch (std::exception* exception, MK_STRN callfunc)  {
    MK_UNUSED auto err = getERR();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MK_ERR __retVal__L = MkErrorCatchTmpl(err, exception, callfunc);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkErrorC::Catch (const std::exception& exception, MK_STRN callfunc)  {
    MK_UNUSED auto err = getERR();
    const std::exception* exception_hdl = &exception;
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MK_ERR __retVal__L = MkErrorCatchTmpl(err, exception_hdl, callfunc);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkErrorC,MkErrorC-Misc,om_
 
  inline void MkErrorC::Cleanup (MK_STRN callfunc, MK_I32 callline)  {
    MK_UNUSED auto err = getERR();
    if (callline == -1) {callline = __builtin_LINE();}
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkErrorCleanup(err, callfunc, callline);
  }
 
  // skip class-overload: Log = MkErrorLog → MkObjectLog
 
  // skip class-overload: Log = MkErrorLog → MkObjectLog
 
  inline void MkErrorC::Println (MK_STRN msg, MK_STRN callfunc, MK_I32 callline)  {
    MK_UNUSED auto err = getERR();
    if (callline == -1) {callline = __builtin_LINE();}
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkErrorPrintln(err, msg, callfunc, callline);
  }
 
  inline void MkErrorC::Reset (MK_STRN callfunc, MK_I32 callline, MK_BOOL force)  {
    MK_UNUSED auto err = getERR();
    if (callline == -1) {callline = __builtin_LINE();}
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkErrorReset(err, callfunc, callline, force);
    MkErrorC_Check(err, errVal);
  }
 
  inline MkErrorE MkErrorC::Stack (MK_STRN callfunc, MK_STRN callfile, MK_I32 callline)  {
    MK_UNUSED auto err = getERR__null_allow();
    if (callline == -1) {callline = __builtin_LINE();}
    if (callfile == NULL) {callfile = __builtin_FILE();}
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkErrorStack(err, callfunc, callfile, callline);
    return errVal;
  }
 
  inline void MkErrorC::StackFormat (MK_STRN callfunc, MK_STRN callfile, MK_I32 callline)  {
    MK_UNUSED auto err = getERR();
    if (callline == -1) {callline = __builtin_LINE();}
    if (callfile == NULL) {callfile = __builtin_FILE();}
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkErrorStackFormat(err, callfunc, callfile, callline);
  }
 
  // skip class-overload: ToString = MkErrorToString → MkObjectToString
 
  // MkErrorC_Misc_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-Raise,oc_
 
  inline MkErrorC* MkErrorC::NoRaise ()  {
    MK_UNUSED auto err = getERR();
    MK_ERR __retVal__L = MkErrorNoRaise(err);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkErrorC,MkErrorC-Raise,om_
 
  inline void MkErrorC::AppendC (MK_STRN message)  {
    MK_UNUSED auto err = getERR();
    MkErrorAppendC(err, message);
  }
 
  inline void MkErrorC::AppendC (const std::string& message)  {
    MK_UNUSED auto err = getERR();
    const MK_STRN message_hdl = message.c_str();
    MkErrorAppendC(err, message_hdl);
  }
 
  inline void MkErrorC::AppendV (MK_FST printfmt, ... )  {
    MK_UNUSED auto err = getERR();
    va_list ap;
    va_start (ap, printfmt);
    MkErrorAppendVL(err, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkErrorC::AppendVL (MK_FST printfmt, va_list var_list)  {
    MK_UNUSED auto err = getERR();
    MkErrorAppendVL(err, printfmt, var_list);
  }
 
  inline void MkErrorC::Raise () const {
    MK_UNUSED auto err = getERRN();
    enum MkErrorE errVal = MkErrorRaise(err);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetC (MK_STRN message, MK_STRN callfunc, MK_I32 errnum)  {
    MK_UNUSED auto err = getERR();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkErrorSetC(err, message, callfunc, errnum);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetC (const std::string& message, MK_STRN callfunc, MK_I32 errnum)  {
    MK_UNUSED auto err = getERR();
    const MK_STRN message_hdl = message.c_str();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkErrorSetC(err, message_hdl, callfunc, errnum);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetV (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )  {
    MK_UNUSED auto err = getERR();
    va_list ap;
    va_start (ap, printfmt);
    enum MkErrorE errVal = MkErrorSetVL(err, callfunc, errnum, printfmt, ap);
    va_end (ap);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetV (const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, ... )  {
    MK_UNUSED auto err = getERR();
    const MK_STRN callfunc_hdl = callfunc.c_str();
    va_list ap;
    va_start (ap, printfmt);
    enum MkErrorE errVal = MkErrorSetVL(err, callfunc_hdl, errnum, printfmt, ap);
    va_end (ap);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetVL (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)  {
    MK_UNUSED auto err = getERR();
    enum MkErrorE errVal = MkErrorSetVL(err, callfunc, errnum, printfmt, var_list);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetVL (const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)  {
    MK_UNUSED auto err = getERR();
    const MK_STRN callfunc_hdl = callfunc.c_str();
    enum MkErrorE errVal = MkErrorSetVL(err, callfunc_hdl, errnum, printfmt, var_list);
    MkErrorC_Check(err, errVal);
  }
 
  // doc-key: MkErrorC,MkErrorC-Raise,sm_
 
  inline void MkErrorC::PanicC (const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    MkPanicC(fmtobj_hdl, callfunc, errnum, message);
  }
 
  inline void MkErrorC::PanicC (const MkObjectC& fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    MkPanicC(fmtobj_hdl, callfunc, errnum, message);
  }
 
  inline void MkErrorC::PanicC (const MkObjectC* fmtobj, const std::string& callfunc, MK_I32 errnum, const std::string& message)  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    const MK_STRN callfunc_hdl = callfunc.c_str();
    const MK_STRN message_hdl = message.c_str();
    MkPanicC(fmtobj_hdl, callfunc_hdl, errnum, message_hdl);
  }
 
  inline void MkErrorC::PanicC (const MkObjectC& fmtobj, const std::string& callfunc, MK_I32 errnum, const std::string& message)  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    const MK_STRN callfunc_hdl = callfunc.c_str();
    const MK_STRN message_hdl = message.c_str();
    MkPanicC(fmtobj_hdl, callfunc_hdl, errnum, message_hdl);
  }
 
  inline void MkErrorC::PanicDEFAULT (const MkObjectC* fmtobj, MK_STRN callfunc)  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkPanicDEFAULT(fmtobj_hdl, callfunc);
  }
 
  inline void MkErrorC::PanicDEFAULT (const MkObjectC& fmtobj, MK_STRN callfunc)  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkPanicDEFAULT(fmtobj_hdl, callfunc);
  }
 
  inline void MkErrorC::PanicV (const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    va_list ap;
    va_start (ap, printfmt);
    MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkErrorC::PanicV (const MkObjectC& fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    va_list ap;
    va_start (ap, printfmt);
    MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkErrorC::PanicV (const MkObjectC* fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, ... )  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    const MK_STRN callfunc_hdl = callfunc.c_str();
    va_list ap;
    va_start (ap, printfmt);
    MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkErrorC::PanicV (const MkObjectC& fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, ... )  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    const MK_STRN callfunc_hdl = callfunc.c_str();
    va_list ap;
    va_start (ap, printfmt);
    MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkErrorC::PanicVL (const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, var_list);
  }
 
  inline void MkErrorC::PanicVL (const MkObjectC& fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, var_list);
  }
 
  inline void MkErrorC::PanicVL (const MkObjectC* fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    const MK_STRN callfunc_hdl = callfunc.c_str();
    MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, var_list);
  }
 
  inline void MkErrorC::PanicVL (const MkObjectC& fmtobj, const std::string& callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    const MK_STRN callfunc_hdl = callfunc.c_str();
    MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, var_list);
  }
 
  // MkErrorC_Raise_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-Signal,om_
 
  inline MK_BOOL MkErrorC::IsABORT () const {
    MK_UNUSED auto err = getERRN();
    MK_BOOL __retVal__L = MkErrorIsABORT(err);
    return __retVal__L;
  }
 
  inline MK_BOOL MkErrorC::IsEXIT ()  {
    MK_UNUSED auto err = getERR();
    MK_BOOL __retVal__L = MkErrorIsEXIT(err);
    return __retVal__L;
  }
 
  inline MK_BOOL MkErrorC::IsSOCKET () const {
    MK_UNUSED auto err = getERRN();
    MK_BOOL __retVal__L = MkErrorIsSOCKET(err);
    return __retVal__L;
  }
 
  inline MK_BOOL MkErrorC::IsTIMEOUT () const {
    MK_UNUSED auto err = getERRN();
    MK_BOOL __retVal__L = MkErrorIsTIMEOUT(err);
    return __retVal__L;
  }
 
  inline void MkErrorC::SetABORT (MK_STRN detail, MK_STRN callfunc)  {
    MK_UNUSED auto err = getERR();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkErrorSetABORT(err, detail, callfunc);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetCONTINUE ()  {
    MK_UNUSED auto err = getERR();
    MkErrorSetCONTINUE(err);
  }
 
  inline void MkErrorC::SetCode (MkErrorE code)  {
    MK_UNUSED auto err = getERR();
    MkErrorSetCode(err, code);
  }
 
  inline void MkErrorC::SetEXIT (MK_STRN callfunc)  {
    MK_UNUSED auto err = getERR();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkErrorSetEXIT(err, callfunc);
    MkErrorC_Check(err, errVal);
  }
 
  inline void MkErrorC::SetSOCKET (MK_STRN detail, MK_STRN callfunc)  {
    MK_UNUSED auto err = getERR();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkErrorSetSOCKET(err, detail, callfunc);
    MkErrorC_Check(err, errVal);
  }
 
  // MkErrorC_Signal_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-System,sc_
 
  inline MkErrorC* MkErrorC::DEFAULT ()  {
    MkRtSetup_NULL;
    MK_ERR __retVal__L = MkErrorDEFAULT();
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkErrorC::FORMAT (const MkObjectC* fmtobj)  {
    MkRtSetup_NULL;
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    MK_ERR __retVal__L = MkErrorFORMAT(fmtobj_hdl);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkErrorC::FORMAT (const MkObjectC& fmtobj)  {
    MkRtSetup_NULL;
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    MK_ERR __retVal__L = MkErrorFORMAT(fmtobj_hdl);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkErrorC::IGNORE ()  {
    MkRtSetup_NULL;
    MK_ERR __retVal__L = MkErrorIGNORE();
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkErrorC::PRINT ()  {
    MkRtSetup_NULL;
    MK_ERR __retVal__L = MkErrorPRINT();
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkErrorC_System_CC_API
 
 
  // doc-key: MkErrorC,MkErrorC-TOR,oCx
 
  inline MkErrorC* MkErrorC::Dup () const {
    MK_UNUSED auto srce = getERRN();
    MK_ERR __retVal__L = MkErrorDup(srce);
    if (__retVal__L == NULL) {
      throw MkInitError("MkErrorC::Dup");
    }
    return MkErrorC::MkErrorC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkErrorC,MkErrorC-TOR,om_
 
  inline void MkErrorC::Copy (const MkErrorC* srce)  {
    MK_UNUSED auto dest = getERR();
    MK_ERRN srce_hdl = MkErrorC::getERRN(srce);
    MkErrorCopy(dest, srce_hdl);
  }
 
  inline void MkErrorC::Copy (const MkErrorC& srce)  {
    MK_UNUSED auto dest = getERR();
    const MK_ERRN srce_hdl = MkErrorC::getERRN(srce);
    MkErrorCopy(dest, srce_hdl);
  }
 
  // MkErrorC_TOR_CC_API
 
  //   END-MkErrorC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
} // END - namespace "ccmkkernel"