theKernel 10.0
Loading...
Searching...
No Matches
Functions
MkErrorC_Raise_CC_API
MK_CC_API » MkErrorC_CC_API

MkErrorC - various functions to 'raise' a MkErrorS … More...

+ Collaboration diagram for MkErrorC_Raise_CC_API:

Functions

MkErrorC * ccmkkernel::MkErrorC::NoRaise ()
  C++: MkErrorC* err.NoRaise() → C-API
ignore the next return of libmkkernel::MK_ERROR and do not raise an target-language-exception …
 
void ccmkkernel::MkErrorC::AppendC (MK_STRN message)
  C++: err.AppendC(MK_STRN message) → C-API
append the message to the MkErrorS::text …
 
void ccmkkernel::MkErrorC::AppendC (const std::string &message)
  C++: err.AppendC(MK_STRN message) → C-API
append the message to the MkErrorS::text …
 
void ccmkkernel::MkErrorC::AppendV (MK_FST printfmt,...)
  C++: err.AppendV(MK_FST printfmt, ... ) → C-API
append a vararg string to the MkErrorC …
 
void ccmkkernel::MkErrorC::AppendVL (MK_FST printfmt, va_list var_list)
  C++: err.AppendVL(MK_FST printfmt, va_list var_list) → C-API
append a va_list string to the MkErrorC …
 
void ccmkkernel::MkErrorC::Raise () const
  C++: err.Raise() → C-API
convert an ccmkkernel error into an programming-language-error and raise afterwards. …
 
void ccmkkernel::MkErrorC::SetC (MK_STRN message, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 errnum=-1)
  C++: err.SetC(MK_STRN message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1) → C-API
'set' and 'raise' the MkErrorC using a string-message and a errnum-number …
 
void ccmkkernel::MkErrorC::SetC (const std::string &message, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 errnum=-1)
  C++: err.SetC(MK_STRN message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1) → C-API
'set' and 'raise' the MkErrorC using a string-message and a errnum-number …
 
void ccmkkernel::MkErrorC::SetV (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt,...)
  C++: err.SetV(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
set the MkErrorS object using a format string argument list and raise an error …
 
void ccmkkernel::MkErrorC::SetV (const std::string &callfunc, MK_I32 errnum, MK_FST printfmt,...)
  C++: err.SetV(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
set the MkErrorS object using a format string argument list and raise an error …
 
void ccmkkernel::MkErrorC::SetVL (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
  C++: err.SetVL(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
'set' and 'raise' the MkErrorC using a vararg-list message …
 
void ccmkkernel::MkErrorC::SetVL (const std::string &callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
  C++: err.SetVL(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
'set' and 'raise' the MkErrorC using a vararg-list message …
 
static void ccmkkernel::MkErrorC::PanicC (const MkObjectC *fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)
  C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …
 
static void ccmkkernel::MkErrorC::PanicC (const MkObjectC &fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)
  C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …
 
static void ccmkkernel::MkErrorC::PanicC (const MkObjectC *fmtobj, const std::string &callfunc, MK_I32 errnum, const std::string &message)
  C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …
 
static void ccmkkernel::MkErrorC::PanicC (const MkObjectC &fmtobj, const std::string &callfunc, MK_I32 errnum, const std::string &message)
  C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …
 
static void ccmkkernel::MkErrorC::PanicDEFAULT (const MkObjectC *fmtobj=NULL, MK_STRN callfunc=__builtin_FUNCTION())
  C++: [static] MkErrorC::PanicDEFAULT(const MkObjectC* fmtobj = NULL, MK_STRN callfunc = __builtin_FUNCTION()) → C-API
make panic from libmkkernel::MkErrorDEFAULT_RT …
 
static void ccmkkernel::MkErrorC::PanicDEFAULT (const MkObjectC &fmtobj, MK_STRN callfunc=__builtin_FUNCTION())
  C++: [static] MkErrorC::PanicDEFAULT(const MkObjectC* fmtobj = NULL, MK_STRN callfunc = __builtin_FUNCTION()) → C-API
make panic from libmkkernel::MkErrorDEFAULT_RT …
 
static void ccmkkernel::MkErrorC::PanicV (const MkObjectC *fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt,...)
  C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …
 
static void ccmkkernel::MkErrorC::PanicV (const MkObjectC &fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt,...)
  C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …
 
static void ccmkkernel::MkErrorC::PanicV (const MkObjectC *fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt,...)
  C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …
 
static void ccmkkernel::MkErrorC::PanicV (const MkObjectC &fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt,...)
  C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …
 
static void ccmkkernel::MkErrorC::PanicVL (const MkObjectC *fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
  C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …
 
static void ccmkkernel::MkErrorC::PanicVL (const MkObjectC &fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
  C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …
 
static void ccmkkernel::MkErrorC::PanicVL (const MkObjectC *fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
  C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …
 
static void ccmkkernel::MkErrorC::PanicVL (const MkObjectC &fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
  C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …
 

Detailed Description

MkErrorC - various functions to 'raise' a MkErrorS …

An error is "raised" by naming the MkErrorS::text and changing the MkErrorS::code to libmkkernel::MK_ERROR.

An error is "raised" by naming the MkErrorS::text and changing the MkErrorS::code to libmkkernel::MK_ERROR.

Function Documentation

◆ AppendC() [1/2]

void ccmkkernel::MkErrorC::AppendC ( const std::string & message)
inline

C++: err.AppendC(MK_STRN message) → C-API
append the message to the MkErrorS::text …

Definition at line 243 of file MkErrorC_inline_cc.hh.

243 {
244 MK_UNUSED auto err = getERR();
245 const MK_STRN message_hdl = message.c_str();
246 MkErrorAppendC(err, message_hdl);
247 }
ccmkkernel::MkErrorC::getERR
MK_ERR getERR() const
return the LibMsgqueObject from current MkErrorC instance
Definition MkErrorC_cc.hh:82
MkErrorAppendC
#define MkErrorAppendC(...)
Definition kernel_overload_mk.h:1115
MK_UNUSED
#define MK_UNUSED
mark unnused variables and functions
Definition LibMkKernel_mk.h:623
libmkkernel::MK_STRN
const MK_STRB * MK_STRN
constant string pointer data-type
Definition LibMkKernel_mk.h:1461

◆ AppendC() [2/2]

void ccmkkernel::MkErrorC::AppendC ( MK_STRN message)
inline

C++: err.AppendC(MK_STRN message) → C-API
append the message to the MkErrorS::text …

Definition at line 237 of file MkErrorC_inline_cc.hh.

237 {
238 MK_UNUSED auto err = getERR();
239 MkErrorAppendC(err, message);
240 }

◆ AppendV()

void ccmkkernel::MkErrorC::AppendV ( MK_FST printfmt,
... )
inline

C++: err.AppendV(MK_FST printfmt, ... ) → C-API
append a vararg string to the MkErrorC …

Definition at line 250 of file MkErrorC_inline_cc.hh.

250 {
251 MK_UNUSED auto err = getERR();
252 va_list ap;
253 va_start (ap, printfmt);
254 MkErrorAppendVL(err, printfmt, ap);
255 va_end (ap);
256 }
MkErrorAppendVL
#define MkErrorAppendVL(...)
Definition kernel_overload_mk.h:1123

◆ AppendVL()

void ccmkkernel::MkErrorC::AppendVL ( MK_FST printfmt,
va_list var_list )
inline

C++: err.AppendVL(MK_FST printfmt, va_list var_list) → C-API
append a va_list string to the MkErrorC …

Definition at line 259 of file MkErrorC_inline_cc.hh.

259 {
260 MK_UNUSED auto err = getERR();
261 MkErrorAppendVL(err, printfmt, var_list);
262 }

◆ NoRaise()

MkErrorC * ccmkkernel::MkErrorC::NoRaise ( )
inline

C++: MkErrorC* err.NoRaise() → C-API
ignore the next return of libmkkernel::MK_ERROR and do not raise an target-language-exception …

Definition at line 228 of file MkErrorC_inline_cc.hh.

228 {
229 MK_UNUSED auto err = getERR();
230 MK_ERR __retVal__L = MkErrorNoRaise(err);
231 return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
232 }
ccmkkernel::MkErrorC::MkErrorC_ObjNew
static MkErrorC * MkErrorC_ObjNew(MK_RT_ARGS MK_ERR hdl)
return MkErrorC from LibMsgqueObject
Definition MkErrorC_cc.hh:77
libmkkernel::MK_ERR
struct MkErrorS * MK_ERR
class-shortcut for struct MkErrorS *, all shortcut using the XX_YYY syntax (only for public API) …
Definition LibMkKernel_mk.h:1576
MkErrorNoRaise
#define MkErrorNoRaise(...)
Definition kernel_overload_mk.h:1109
MK_RT_CALL
#define MK_RT_CALL
Definition LibMkKernel_mk.h:895

◆ PanicC() [1/4]

void ccmkkernel::MkErrorC::PanicC ( const MkObjectC & fmtobj,
const std::string & callfunc,
MK_I32 errnum,
const std::string & message )
inlinestatic

C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …

Definition at line 350 of file MkErrorC_inline_cc.hh.

350 {
351 MkRtSetup_NULL;
352 const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
353 const MK_STRN callfunc_hdl = callfunc.c_str();
354 const MK_STRN message_hdl = message.c_str();
355 MkPanicC(fmtobj_hdl, callfunc_hdl, errnum, message_hdl);
356 }
MkPanicC
#define MkPanicC(...)
Definition kernel_overload_mk.h:1192
ccmkkernel::MkObjectC::getOBJN
MK_OBJN getOBJN() const
(const) return the LibMsgqueObject from current MkObjectC instance
Definition MkObjectC_cc.hh:101
libmkkernel::MK_OBJN
const struct MkObjectS * MK_OBJN
class-shortcut for const struct MkObjectS *, all const shortcut using the XX_YYYC syntax (only for pu...
Definition LibMkKernel_mk.h:1509
MkRtSetup_NULL
#define MkRtSetup_NULL
Definition LibMkKernel_mk.h:12456

◆ PanicC() [2/4]

void ccmkkernel::MkErrorC::PanicC ( const MkObjectC & fmtobj,
MK_STRN callfunc,
MK_I32 errnum,
MK_STRN message )
inlinestatic

C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …

Definition at line 334 of file MkErrorC_inline_cc.hh.

334 {
335 MkRtSetup_NULL;
336 const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
337 MkPanicC(fmtobj_hdl, callfunc, errnum, message);
338 }

◆ PanicC() [3/4]

void ccmkkernel::MkErrorC::PanicC ( const MkObjectC * fmtobj,
const std::string & callfunc,
MK_I32 errnum,
const std::string & message )
inlinestatic

C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …

Definition at line 341 of file MkErrorC_inline_cc.hh.

341 {
342 MkRtSetup_NULL;
343 MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
344 const MK_STRN callfunc_hdl = callfunc.c_str();
345 const MK_STRN message_hdl = message.c_str();
346 MkPanicC(fmtobj_hdl, callfunc_hdl, errnum, message_hdl);
347 }
ccmkkernel::MkObjectC::getOBJN__null_allow
MK_OBJN getOBJN__null_allow() const
(const) return the LibMsgqueObject from current MkObjectC instance
Definition MkObjectC_cc.hh:108

◆ PanicC() [4/4]

void ccmkkernel::MkErrorC::PanicC ( const MkObjectC * fmtobj,
MK_STRN callfunc,
MK_I32 errnum,
MK_STRN message )
inlinestatic

C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message) → C-API
do a panic with string as argument …

Definition at line 327 of file MkErrorC_inline_cc.hh.

327 {
328 MkRtSetup_NULL;
329 MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
330 MkPanicC(fmtobj_hdl, callfunc, errnum, message);
331 }

◆ PanicDEFAULT() [1/2]

void ccmkkernel::MkErrorC::PanicDEFAULT ( const MkObjectC & fmtobj,
MK_STRN callfunc = __builtin_FUNCTION() )
inlinestatic

C++: [static] MkErrorC::PanicDEFAULT(const MkObjectC* fmtobj = NULL, MK_STRN callfunc = __builtin_FUNCTION()) → C-API
make panic from libmkkernel::MkErrorDEFAULT_RT …

Definition at line 367 of file MkErrorC_inline_cc.hh.

367 {
368 MkRtSetup_NULL;
369 const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
370 if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
371 MkPanicDEFAULT(fmtobj_hdl, callfunc);
372 }
MkPanicDEFAULT
#define MkPanicDEFAULT(...)
Definition kernel_overload_mk.h:1197

◆ PanicDEFAULT() [2/2]

void ccmkkernel::MkErrorC::PanicDEFAULT ( const MkObjectC * fmtobj = NULL,
MK_STRN callfunc = __builtin_FUNCTION() )
inlinestatic

C++: [static] MkErrorC::PanicDEFAULT(const MkObjectC* fmtobj = NULL, MK_STRN callfunc = __builtin_FUNCTION()) → C-API
make panic from libmkkernel::MkErrorDEFAULT_RT …

Definition at line 359 of file MkErrorC_inline_cc.hh.

359 {
360 MkRtSetup_NULL;
361 MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
362 if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
363 MkPanicDEFAULT(fmtobj_hdl, callfunc);
364 }

◆ PanicV() [1/4]

void ccmkkernel::MkErrorC::PanicV ( const MkObjectC & fmtobj,
const std::string & callfunc,
MK_I32 errnum,
MK_FST printfmt,
... )
inlinestatic

C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …

Definition at line 406 of file MkErrorC_inline_cc.hh.

406 {
407 MkRtSetup_NULL;
408 const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
409 const MK_STRN callfunc_hdl = callfunc.c_str();
410 va_list ap;
411 va_start (ap, printfmt);
412 MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, ap);
413 va_end (ap);
414 }
MkPanicVL
#define MkPanicVL(...)
Definition kernel_overload_mk.h:1206

◆ PanicV() [2/4]

void ccmkkernel::MkErrorC::PanicV ( const MkObjectC & fmtobj,
MK_STRN callfunc,
MK_I32 errnum,
MK_FST printfmt,
... )
inlinestatic

C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …

Definition at line 385 of file MkErrorC_inline_cc.hh.

385 {
386 MkRtSetup_NULL;
387 const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
388 va_list ap;
389 va_start (ap, printfmt);
390 MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, ap);
391 va_end (ap);
392 }

◆ PanicV() [3/4]

void ccmkkernel::MkErrorC::PanicV ( const MkObjectC * fmtobj,
const std::string & callfunc,
MK_I32 errnum,
MK_FST printfmt,
... )
inlinestatic

C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …

Definition at line 395 of file MkErrorC_inline_cc.hh.

395 {
396 MkRtSetup_NULL;
397 MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
398 const MK_STRN callfunc_hdl = callfunc.c_str();
399 va_list ap;
400 va_start (ap, printfmt);
401 MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, ap);
402 va_end (ap);
403 }

◆ PanicV() [4/4]

void ccmkkernel::MkErrorC::PanicV ( const MkObjectC * fmtobj,
MK_STRN callfunc,
MK_I32 errnum,
MK_FST printfmt,
... )
inlinestatic

C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
do a panic with a vararg as argument …

Definition at line 375 of file MkErrorC_inline_cc.hh.

375 {
376 MkRtSetup_NULL;
377 MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
378 va_list ap;
379 va_start (ap, printfmt);
380 MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, ap);
381 va_end (ap);
382 }

◆ PanicVL() [1/4]

void ccmkkernel::MkErrorC::PanicVL ( const MkObjectC & fmtobj,
const std::string & callfunc,
MK_I32 errnum,
MK_FST printfmt,
va_list var_list )
inlinestatic

C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …

Definition at line 439 of file MkErrorC_inline_cc.hh.

439 {
440 MkRtSetup_NULL;
441 const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
442 const MK_STRN callfunc_hdl = callfunc.c_str();
443 MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, var_list);
444 }

◆ PanicVL() [2/4]

void ccmkkernel::MkErrorC::PanicVL ( const MkObjectC & fmtobj,
MK_STRN callfunc,
MK_I32 errnum,
MK_FST printfmt,
va_list var_list )
inlinestatic

C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …

Definition at line 424 of file MkErrorC_inline_cc.hh.

424 {
425 MkRtSetup_NULL;
426 const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
427 MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, var_list);
428 }

◆ PanicVL() [3/4]

void ccmkkernel::MkErrorC::PanicVL ( const MkObjectC * fmtobj,
const std::string & callfunc,
MK_I32 errnum,
MK_FST printfmt,
va_list var_list )
inlinestatic

C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …

Definition at line 431 of file MkErrorC_inline_cc.hh.

431 {
432 MkRtSetup_NULL;
433 MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
434 const MK_STRN callfunc_hdl = callfunc.c_str();
435 MkPanicVL(fmtobj_hdl, callfunc_hdl, errnum, printfmt, var_list);
436 }

◆ PanicVL() [4/4]

void ccmkkernel::MkErrorC::PanicVL ( const MkObjectC * fmtobj,
MK_STRN callfunc,
MK_I32 errnum,
MK_FST printfmt,
va_list var_list )
inlinestatic

C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
do a panic with a vararg-list as argument …

Definition at line 417 of file MkErrorC_inline_cc.hh.

417 {
418 MkRtSetup_NULL;
419 MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
420 MkPanicVL(fmtobj_hdl, callfunc, errnum, printfmt, var_list);
421 }

◆ Raise()

void ccmkkernel::MkErrorC::Raise ( ) const
inline

C++: err.Raise() → C-API
convert an ccmkkernel error into an programming-language-error and raise afterwards. …

Definition at line 265 of file MkErrorC_inline_cc.hh.

265 {
266 MK_UNUSED auto err = getERRN();
267 enum MkErrorE errVal = MkErrorRaise(err);
268 MkErrorC_Check(err, errVal);
269 }
MkErrorC_Check
#define MkErrorC_Check(errObj, errVal)
Definition MkErrorC_cc.hh:491
ccmkkernel::MkErrorC::getERRN
MK_ERRN getERRN() const
(const) return the LibMsgqueObject from current MkErrorC instance
Definition MkErrorC_cc.hh:94
MkErrorRaise
#define MkErrorRaise(...)
Definition kernel_overload_mk.h:1127
libmkkernel::MkErrorE
MkErrorE
collection for the different error-codes …
Definition LibMkKernel_mk.h:1850

◆ SetC() [1/2]

void ccmkkernel::MkErrorC::SetC ( const std::string & message,
MK_STRN callfunc = __builtin_FUNCTION(),
MK_I32 errnum = -1 )
inline

C++: err.SetC(MK_STRN message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1) → C-API
'set' and 'raise' the MkErrorC using a string-message and a errnum-number …

Definition at line 280 of file MkErrorC_inline_cc.hh.

280 {
281 MK_UNUSED auto err = getERR();
282 const MK_STRN message_hdl = message.c_str();
283 if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
284 enum MkErrorE errVal = MkErrorSetC(err, message_hdl, callfunc, errnum);
285 MkErrorC_Check(err, errVal);
286 }
MkErrorSetC
#define MkErrorSetC(...)
Definition kernel_overload_mk.h:1133

◆ SetC() [2/2]

void ccmkkernel::MkErrorC::SetC ( MK_STRN message,
MK_STRN callfunc = __builtin_FUNCTION(),
MK_I32 errnum = -1 )
inline

C++: err.SetC(MK_STRN message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1) → C-API
'set' and 'raise' the MkErrorC using a string-message and a errnum-number …

Definition at line 272 of file MkErrorC_inline_cc.hh.

272 {
273 MK_UNUSED auto err = getERR();
274 if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
275 enum MkErrorE errVal = MkErrorSetC(err, message, callfunc, errnum);
276 MkErrorC_Check(err, errVal);
277 }

◆ SetV() [1/2]

void ccmkkernel::MkErrorC::SetV ( const std::string & callfunc,
MK_I32 errnum,
MK_FST printfmt,
... )
inline

C++: err.SetV(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
set the MkErrorS object using a format string argument list and raise an error …

Definition at line 299 of file MkErrorC_inline_cc.hh.

299 {
300 MK_UNUSED auto err = getERR();
301 const MK_STRN callfunc_hdl = callfunc.c_str();
302 va_list ap;
303 va_start (ap, printfmt);
304 enum MkErrorE errVal = MkErrorSetVL(err, callfunc_hdl, errnum, printfmt, ap);
305 va_end (ap);
306 MkErrorC_Check(err, errVal);
307 }
MkErrorSetVL
#define MkErrorSetVL(...)
Definition kernel_overload_mk.h:1178

◆ SetV() [2/2]

void ccmkkernel::MkErrorC::SetV ( MK_STRN callfunc,
MK_I32 errnum,
MK_FST printfmt,
... )
inline

C++: err.SetV(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... ) → C-API
set the MkErrorS object using a format string argument list and raise an error …

Definition at line 289 of file MkErrorC_inline_cc.hh.

289 {
290 MK_UNUSED auto err = getERR();
291 va_list ap;
292 va_start (ap, printfmt);
293 enum MkErrorE errVal = MkErrorSetVL(err, callfunc, errnum, printfmt, ap);
294 va_end (ap);
295 MkErrorC_Check(err, errVal);
296 }

◆ SetVL() [1/2]

void ccmkkernel::MkErrorC::SetVL ( const std::string & callfunc,
MK_I32 errnum,
MK_FST printfmt,
va_list var_list )
inline

C++: err.SetVL(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
'set' and 'raise' the MkErrorC using a vararg-list message …

Definition at line 317 of file MkErrorC_inline_cc.hh.

317 {
318 MK_UNUSED auto err = getERR();
319 const MK_STRN callfunc_hdl = callfunc.c_str();
320 enum MkErrorE errVal = MkErrorSetVL(err, callfunc_hdl, errnum, printfmt, var_list);
321 MkErrorC_Check(err, errVal);
322 }

◆ SetVL() [2/2]

void ccmkkernel::MkErrorC::SetVL ( MK_STRN callfunc,
MK_I32 errnum,
MK_FST printfmt,
va_list var_list )
inline

C++: err.SetVL(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list) → C-API
'set' and 'raise' the MkErrorC using a vararg-list message …

Definition at line 310 of file MkErrorC_inline_cc.hh.

310 {
311 MK_UNUSED auto err = getERR();
312 enum MkErrorE errVal = MkErrorSetVL(err, callfunc, errnum, printfmt, var_list);
313 MkErrorC_Check(err, errVal);
314 }
Generated on Thu May 29 2025 13:13:27 for theKernel by doxygen 1.12.0