theKernel 10.0
Loading...
Searching...
No Matches
LibMkKernel_mk.h File Reference
#include <inttypes.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <stdbool.h>
#include <assert.h>
#include "gen/kernel_overload_mk.h"
#include "MkBufferListC_def_mk.h"
+ Include dependency graph for LibMkKernel_mk.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  libmkkernel::MK_STRN_A
 array of libmkkernel::MK_STRN values … More...
 
struct  libmkkernel::MkBinaryR
 binary data default format … More...
 
struct  libmkkernel::MkStringR
 string data default format … More...
 
union  libmkkernel::MkBufferAtomU
 union used to set or modify native data from an MkBufferS object … More...
 
union  libmkkernel::MkBufferU
 a union for all data items supported by MkBufferSMore...
 
struct  libmkkernel::MkIdS
 data type for process/thread identification … More...
 
struct  libmkkernel::MkCacheItemS
 a linked-list to opearate a storage of data items More...
 
struct  libmkkernel::MkCacheS
 This is an circel storage of a linked-list connected with a "lock" at libmkkernel::MkCacheSMore...
 
struct  libmkkernel::MkLalS
 Interface between ccmkkernel and the Operating-System … More...
 
struct  libmkkernel::MkObjectProtectS
 the protect is used to "protect" data set by pAllocCreate if the new object is later initialized with a type specific object-initialization … More...
 
struct  libmkkernel::MkObjectS
 object header … More...
 
struct  libmkkernel::MkAllocDefS
 define the storage-allocator function More...
 
struct  libmkkernel::MkTypeS
 MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type … More...
 
struct  libmkkernel::MkTypeDefS
 super-class-base, the MkTypeS using the super-macro-syntax for all non specific types … More...
 
struct  libmkkernel::MkBufferS
 The ABSTRACT-CLASS used to store a native-type-data-item defined by PRIMITIVE TYPEMore...
 
struct  libmkkernel::MkBufferS::ilsS
 instance storage predefined More...
 
struct  libmkkernel::MkBuffer64S
 the final class of MkBufferS with 64 byte ILS-SizeMore...
 
struct  libmkkernel::MkBuffer256S
 the final class of MkBufferS with 256 byte ILS-SizeMore...
 
struct  libmkkernel::MkBuffer1024S
 the final class of MkBufferS with 1024 byte ILS-SizeMore...
 
struct  libmkkernel::MkBufferStreamS
 The ABSTRACT-CLASS MkBufferStreamS is used for package-based serialized IOMore...
 
struct  libmkkernel::MkBufferStream64S
 the final class of MkBufferStreamS with 64 byte ILS-SizeMore...
 
struct  libmkkernel::MkBufferStream256S
 the final class of MkBufferStreamS with 256 byte ILS-SizeMore...
 
struct  libmkkernel::MkBufferStream1024S
 the final class of MkBufferStreamS with 1024 byte ILS-SizeMore...
 
struct  libmkkernel::MkBufferStream16384S
 the final class of MkBufferStreamS with 16384 byte ILS-SizeMore...
 
struct  libmkkernel::MkLogDataS
 struct to hold the mkrt-logging-dataMore...
 
struct  libmkkernel::MkLogFileS
 define a MkLogFileC object … More...
 
struct  libmkkernel::MkExtensionS
 Base class for the extension technologie … More...
 
struct  libmkkernel::MkErrorS
 The data-type to store and handle the error-conditionMore...
 
struct  libmkkernel::MkErrExtS
 extension-slot for MkErrorSMore...
 
struct  libmkkernel::MkErrorPanicS
 signal-slot for panic on errorMore...
 
struct  libmkkernel::MkErrorExitS
 signal-slot for panic on errorMore...
 
struct  libmkkernel::MkErrorIgnoreS
 signal-slot for ignore on errorMore...
 
struct  libmkkernel::MkErrorPrintS
 signal-slot for print on errorMore...
 
struct  libmkkernel::MkErrorDefaultS
 signal-slot for raise an errorMore...
 
struct  libmkkernel::MkRtExtS
 MkRtExtS - extend the MkRuntimeC with a library specific feature … More...
 
struct  libmkkernel::MkThreadDataS
 
struct  libmkkernel::MkRuntimeS
 The MkRuntimeS provide a per-thread environment for ccmkkernelMore...
 
struct  libmkkernel::MkRuntimeCallbackS
 keep callback related data … More...
 

Namespaces

namespace  libmkkernel
 

Macros

#define META_TIMEOUT_REF   900
 
#define META_HDL_USE__NONNULL__GCC_ATTRIBUTE   0
 
#define META_DOXYGEN_USE_C_PRIVAT   0
 
#define META_DEBUG_ALL   -1 /* The C standard guarantees that assigning -1 sets all bits. */
 
#define META_DEBUG_DEFAULT   (1<<1)
 
#define META_DEBUG_CACHE   (1<<2)
 
#define META_DEBUG_TYPE   (1<<3)
 
#define META_DEBUG_SOCKET   (1<<4)
 
#define META_DEBUG_EVENT   (1<<5)
 
#define META_DEBUG_MEM   (1<<6)
 
#define META_DEBUG_REFCOUNT   (1<<7)
 
#define META_DEBUG_ERROR   (1<<8)
 
#define META_DEBUG_TYPE__printV(...)
 
#define META_DEBUG_ERROR_check()
 raise worning if function is call with ACTIVE error set
 
#define META_DEBUG_ERROR_checkX(x)
 
#define META_DEBUG_ERROR_checkO(o)
 
#define MkDDInit   const MK_I32 __dbg = MK_RT_REF.debug
 
#define MkDDInitNum(n)
 
#define MkDProtect(_debug)
 
#define MkDProtect2(_debug, _call)
 
#define META_USE_SELF_REFCOUNT
 
#define MK_RT_ATTR_FORMAT_1   __attribute__((format (printf, 1+MK_RT_SHIFT, 2+MK_RT_SHIFT)));
 
#define MK_RT_ATTR_FORMAT_2   __attribute__((format (printf, 2+MK_RT_SHIFT, 3+MK_RT_SHIFT)))
 
#define MK_RT_ATTR_FORMAT_4   __attribute__((format (printf, 4+MK_RT_SHIFT, 5+MK_RT_SHIFT)))
 
#define __MK_ATTR_RT_RUNTIME
 
#define __MK_ATTR_RT_INSTANCE
 
#define __MK_ATTR_INSTANCE
 
#define MK_INSTANCE_HDL(x)
 
#define MK_ATTR_INSTANCE   __MK_ATTR_INSTANCE
 
#define MK_ATTR_RT_INSTANCE   __MK_ATTR_RT_RUNTIME __MK_ATTR_RT_INSTANCE
 
#define MK_ATTR_STATIC   __parser__(static)
 
#define MK_ATTR_RT_STATIC   __MK_ATTR_RT_RUNTIME __parser__(static)
 
#define MK_INSTANCE_RT_X(x)
 
#define MK_INSTANCE_RT_X_NULL(x)
 
#define MK_INSTANCE_RT_O(o)
 
#define MK_INSTANCE_RT_O_NULL(o)
 
#define MK_DESTRUCTOR_RT_X(c, x)
 
#define MK_STATIC_RT   MkRtSetup_NULL_RT; META_DEBUG_ERROR_check()
 
#define META_DIR_SEPARATOR   '/'
 
#define META_EOL   "\n"
 
#define MK_EXTERN
 static library
 
#define MK_EXTERN_DATA   extern
 
#define MK_CPPXSTR(s)
 connecting of expressions, step 1 …
 
#define MK_CPPSTR(s)
 connecting of expressions, step 2 …
 
#define MK_CONCAT(a, b)
 concat of expressions, step 2 …
 
#define MK_CONCAT2(a, b)
 
#define MK_CONCAT3(a, b, c)
 
#define mk_append_fix_str(t, s)
 append fix string to storage and increment pointer …
 
#define mk_bit_compare(t, f)
 bitwise compare flag values …
 
#define MK_ALFA   '@'
 MK_ALFA the command-line separator between server and client …
 
#define MK_ALFA_STR   ((MkStringR){1,"@"})
 MK_ALFA the command-line separator as string …
 
#define MkCacheItemS_signature   0x44196912
 
#define MkCacheS_name_size   32
 
#define MkCacheS_MkCacheItemS_size   8
 
#define MkSysFree(pointer)
 
#define MkSysFreeNonNull(pointer)
 
#define MkSysStringSetNULL_R(_str)
 
#define MkSysStringSet_R(_str, _val)
 
#define MkSysStringIsNULL_R(_str)
 
#define MkSysStringIsEQUAL(_str, _other)
 
#define MkSysStringIsLenEQUAL(_str, _other, _len)
 
#define MK_NULL_SIGNATURE   0
 signature used to mark an invalid signature …
 
#define MkDbgObjInstancesO_2(o, c)
 
#define MkDbgObjInstancesX_2(x, c)
 
#define MkDbgObjInstancesX(x)
 
#define MkDbgObjInstancesO(o)
 
#define MkDbgDeepWriter(...)
 
#define MkDbgDeepX_4(m, ident, func, fmt, ...)
 
#define MkDbgDeepX_3(m, ident, fmt, ...)
 
#define MkDbgDeepX_2(m, ident)
 
#define MkDbgTyp2(t, c)
 
#define MkDbgTyp(t)
 
#define MkDbgTypListAll2(t, c)
 
#define MkDbgTypListAll(t)
 
#define MkDbgTypInstances_2(t, c)
 
#define MkDbgTypInstances(t)
 
#define MkTypeS_name_size   32
 
#define MkTYP_R(x)
 cast a known-managed-object into an MkTypeS reference
 
#define MkTYP(x)
 cast a known-managed-object into an MkTypeS pointer
 
#define MkTYP_O(o)
 cast an o-instance into an MkTypeS pointer
 
#define MkTYP_X(x)
 cast an x-instance into an MkTypeS pointer
 
#define MkTypeSlotResolve(_tt, fptr, force)
 search and return functionPtr(slot) for the tt-type.
 
#define MkTypeSlotCall(_tt, fptr, ...)
 
#define MkObjInit2(rtmkV, rtExtV, sigV, typeV, refCountV, isLocalV)
 Initialize an libmkkernel::MkObjectS.
 
#define MkObjInit(rtmkV, rtExtV, cls, refCountV, isLocalV)
 
#define MkObjInitFromType(typeV, isLocalV)
 
#define MkObjInitFromInstance(instV)
 
#define MkObjectDelete_NULL(obj)
 
#define MkObjectDelete_NULL_X(x)
 
#define MkObjectDelete_1X(x)
 
#define MkObjectDeleteToNull(fct, NS, x)
 
#define MkObjectDeleteToNull_X(fct, NS, x)
 
#define MkObjectDispose_NULL(obj)
 
#define MkObjectDispose_NULL_X(x)
 
#define MkObjectDispose_1X(x)
 
#define MkObjectDeleteCallF_CHECK
 validate call to libmkkernel::MkObjectDeleteCallF
 
#define MkObjectDeleteCallF_ARGS
 the libmkkernel::MkObjectDeleteCallF arguments with default names
 
#define MkObjectDeleteCallF_CALL   MK_RT_CALL obj, __data__
 
#define MkObjectDeleteFreeF_ARGS   MK_RT_ARGS MK_CBP *dataP __parser__(inout)
 the libmkkernel::MkObjectDeleteFreeF arguments with default names
 
#define MkTypeCreate(clsV, basicV, identV)
 
#define MkTypeForeachInstancesSave(typ)
 
#define MkTypeLog_2Lvl(t, l, ...)
 
#define MkTypeLoop(_cls, _var)
 
#define MkObjectToName_1X(x)
 
#define MkObjectToNameOfType_1X(x)
 
#define MkObjectToNameOfClass_1X(x)
 
#define MkObjectToString_1X(x)
 
#define MkObjectToString_1M(m)
 
#define MkLogC_4X(x, message, debug, callfunc)
 
#define MkLogC_3X(x, message, debug)
 
#define MkLogC_2X(x, message)
 
#define MkLogW(x, callfunc, _debug, message)
 
#define MkDbgV_2X(x, printfmt, ...)
 
#define MkDbgV_2O(o, printfmt, ...)
 
#define MkLogV_lvl(x, debug, printfmt, ...)
 
#define MkLogV_4M(x, callfunc, debug, printfmt, ...)
 
#define MkLogV_4X(x, callfunc, debug, printfmt, ...)
 
#define MkLogV_3X(x, callfunc, printfmt, ...)
 
#define MkLogV_2X(x, printfmt, ...)
 
#define MkLogVL_5X(fmtobj, callfunc, debug, printfmt, var_list)
 
#define MkLogHEX_4X(fmtobj, callfunc, data, len)
 
#define MkObjectLogShort_1X(x)
 
#define MkObjectLogShort_2Lvl(o, l)
 
#define MkObjectLogLong_1X(x)
 
#define MkObjectLogLong_1M(m)
 
#define MkObjectLogLong_1X(x)
 
#define MkObjectLogLong_1M(m)
 
#define MkObjectLog_1X(x)
 
#define MkObjectLog_2Lvl(o, l)
 
#define MkDbgL_2M(x, message)
 
#define MkDbgDump_2M(x, message)
 
#define MkDbgSTACK_3X(x, num, callfunc)
 
#define MkDbgO_2X(x, callfunc)
 
#define MkDbgO_1X(x)
 
#define MkDbgO_1O(x)
 
#define MkDbgLogC_2X(x, callfunc)
 debug: write a short-obj-summary to MkLogFileC (default: stderr) …
 
#define MkBufferS_ils_size   (0)
 64 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBuffer64S_ils_size   (64)
 64 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBuffer256S_ils_size   (256)
 256 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBuffer1024S_ils_size   (1024)
 1024 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBufferCreateTLS_T(cls, name, size)
 create an new MkBufferC object as T)hread L)ocal S)torage…
 
#define MkBufferCreateTLS_inout_T(cls, name, inout)
 Constructs a MkBufferC instance as T)hread L)ocal S)torage OR reuse inout if possible…
 
#define MkBufferCreateLOCAL_T(cls, name, size)
 create an new MkBufferC object as L)ocal S)torage…
 
#define MkBufferLogS_2V(buf, fmt)
 
#define MkBufferStreamS_ils_size   (0)
 64 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBufferStream64_ils_size   (64)
 64 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBufferStream256S_ils_size   (256)
 256 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBufferStream1024_ils_size   (1024)
 1024 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBufferStream16384S_ils_size   (16384)
 16384 bytes I)instance L)ocal S)torage - the memory that adds the final-class to the abstract-class.
 
#define MkBufferStreamCreateLOCAL_T(cls, name, size)
 Constructs a MkBufferStreamC instance as L)ocal S)torage …
 
#define MkBufferStreamCreateSTATIC_T(cls, name)
 Constructs a MkBufferStreamC instance as S)tatic S)torage …
 
#define MkBufferStreamCreateTLS_T(cls, name)
 Constructs a MkBufferStreamC instance as T)hread L)ocal S)torage …
 
#define MkBufferStreamLog_5F(bus, fmt, ...)
 
#define MkBufferStreamLog_2F(bus, fmt)
 
#define MkBufferStreamLog_3F(bus, fmt, pfx)
 
#define MkDbgLogData(d)
 
#define MkLogDataEA(e)
 
#define MkLogDataS_LogNAME_size   256
 append to logFILE, valid values are: stderr, stdout or a filename (default: stderr)
 
#define MkDbgMkExt2(c, x)
 
#define MkDbgMkExt(x)
 
#define MkExtension_size   64
 maximum number of runtime-extensions useable in a theKernel software.
 
#define MkDbgErr_2(err, col)
 
#define MkDbgErr(err)
 
#define MK_ERREXT_ARGS   MK_RT_ARGS MK_ERR const mkerr, MK_ERREXT const errext
 
#define MK_ERREXT_CALL   MK_RT_CALL err, errext
 
#define MK_ERREXT_ARGS_N   MK_RT_ARGS MK_ERRN const mkerr, MK_ERREXT const errext
 
#define MK_ERREXT_CALL_N   MK_RT_CALL err, errext
 
#define MkErrExtAdd(_mkerrR, add)
 
#define MkErrExtDel(_mkerrR, del)
 
#define MkErrorGetCodeI(e)
 get the value of MkErrorS::code
 
#define MkErrorGetCodeE_NULL()
 get the value of MkErrorS::code
 
#define MkErrorGetCode_O(o)
 get the value of MkErrorS::code
 
#define MkErrorGetTextI(e)
 get the MkErrorS::text
 
#define MkErrorGetSizeI(e)
 get the error-message-size from the exception-object
 
#define MkErrorGetNumI(e)
 get the MkErrorS::num. The number can be used as exit-code …
 
#define MkErrorCheck(err)
 check return-code and goto error on error …
 
#define MkErrorE_Check(err)
 check return-code and goto error on error …
 
#define MkErrorCheck_0E()
 check return-code and goto error on error …
 
#define MkErrorBreak(err)
 check return-code and break on error …
 
#define MkContinueCheck(err)
 check on MK_ERROR and MK_CONTINUE - jump to label …
 
#define MkErrorSwitch(PROC)
 process error message …
 
#define MkErrorReturn_2X(mngx, PROC)
 process error message …
 
#define MkErrorReturn_1(PROC)
 process error message …
 
#define MkErrorReturn(PROC)
 process error message …
 
#define check_MkErrorE(PROC)
 check MkErrorE macro …
 
#define MkErrorReturnLabel(mng)
 default return from function with error-label set …
 
#define MkPanicVL_5M(errobj, callfunc, errnum, printfmt, var_list)
 
#define MkPanicV_4M(errobj, callfunc, errnum, printfmt, ...)
 
#define MkPanicV_2M(x, printfmt, ...)
 
#define MkPanicC_4M(errobj, callfunc, errnum, message)
 
#define MkPanicC_2M(x, message)
 
#define MkPanicDEFAULT_2M(errobj, ...)
 
#define MkPanicDEFAULT_1M(x)
 
#define MkPanicSYS(mngx)
 do a panic with a system error message …
 
#define MkErrorSetC_1XS(message)
 
#define MkErrorSetC_2E_E(caller, message)
 
#define MkErrorSetC_4_NULL(...)
 
#define MkErrorSetC_3_NULL(...)
 
#define MkErrorSetC_2_NULL(msg, pfx)
 
#define MkErrorSetC_1_NULL(msg)
 
#define MkErrorSetC_4M_NULL(m, ...)
 
#define MkErrorSetC_3M_NULL(m, msg, pfx)
 
#define MkErrorSetC_2M_NULL(m, msg)
 
#define MkErrorSetV_4EO_NULL(o, ...)
 
#define MkErrorSetV_4M_NULL(m, ...)
 
#define MkErrorSetV_2M_NULL(m, ...)
 
#define MkErrorSetV_2X(x, ...)
 
#define MkErrorSetV_1_NULL(printfmt, ...)
 
#define MkErrorSetV_1XS(printfmt, ...)
 
#define MkErrorSetV_2E_E(caller, printfmt, ...)
 
#define MkErrorSet_ObjectIsNullError(m, printfmt, ...)
 
#define MkErrorSysO(obj, cmd)
 
#define MkErrorPrintln_0()
 
#define MkErrorLog_1EF_NULL(fmt)
 
#define MkErrorLog_1EF(fmt)
 
#define MkObjectErrorCatch_3X(x, ...)
 inline for MkObjectErrorCatch
 
#define MkErrorReset_0M()
 
#define MkErrorResetFORCE_1(m)
 
#define MkErrorResetFORCE_0()
 
#define MkErrorReset_4X(x, ...)
 
#define MkErrorReset_1X(x)
 
#define MkErrorStack_1M_Check(m)
 
#define MkErrorStack_0E_Check()
 
#define MkErrorStack_4X(x, ...)
 
#define MkErrorStack_3X(...)
 
#define MkErrorStack_2X(...)
 
#define MkErrorStack_1X(...)
 
#define MkErrorStack_0_NULL()
 
#define MkErrorStack_4X_NULL(x, ...)
 
#define MkErrorStack_3X_NULL(...)
 
#define MkErrorStack_2X_NULL(...)
 
#define MkErrorStack_1X_NULL(...)
 
#define MkErrorStack_NUM   50
 
#define MkErrorStack_STR   "50"
 
#define MkRtExtAdd(_mkrtR, add, id)
 
#define MkRtExtDel(_mkrtR, del, id)
 
#define MkDbgRt_1(c)
 
#define MkDbgRt()
 
#define MkDbgRtChkX(x)
 
#define MkRuntimeCallbackS_ident_size   30
 
#define MkRuntimeLogBufferPush()
 
#define MkRuntimeLogBufferPop()
 
#define MK_EMBEDDED(type, call, ...)
 macro to create "embedded" (*_e) Version of C-API call's
 
#define MK_EMBEDDED_REF(type, call, ...)
 macro to create "embedded" (*_e) Version of C-API call's
 
#define MkObjectToError_1X(obj)
 
evaluate CODE in debug …

_debug

#define MkDCheck(_debug)
 
#define MkDDCheck(_debug)
 
log a plain string …
Parameters
[in]fmtobjmanaged object used to format the log-message (default=MK_NULL → use default-format) _debug
strthe message to log
#define MkDLogC_O(fmtobj, _debug, str)
 
#define MkDLogC(x, _debug, str)
 
#define MkDDLogC(x, _debug, str)
 
log a vararg string using formatting and checking for logging debug …
Parameters
[in]fmtobjmanaged object used to format the log-message (default=MK_NULL → use default-format) _debug
[in]printfmtis a c-string used as printf like format string
...vararg string argument
#define MkDLogV_O(fmtobj, _debug, printfmt, ...)
 
#define MkDLogV(x, _debug, printfmt, ...)
 
#define MkDDLogV(fmtobj, _debug, printfmt, ...)
 
local attributes

parser: A local-attribute is only used in the object-level (function, type etc) …

See also
__parser__(...)
#define __parser__(...)
 parser: apply an attribute to an object in local scope …
 
#define __parser__define__(...)
 parser: define a local attribute which can be used with __parser__
 
#define __parser__push__(...)
 parser: start apply a list of local attributes to a block of code …
 
#define __parser__pop__
 parser: stop apply a list of local attributes to a block of code …
 
global attributes

parser : A global-attribute is only used at the top-level and always end with a ";"

See also
__parser__global__(...)
#define __parser__global__(...)
 parser: apply an attribute to a dunction in global scope …
 
#define __parser__global__define__(...)
 parser: define an globale attribute which can be used with __parser__(...) or __parser__global__(...)
 
#define __parser__global__push__(...)
 parser: start apply a list of global attributes to a block of function …
 
#define __parser__global__pop__
 parser: stop apply a list of global attributes to a block of function …
 
global <strong>parser</strong> definition
#define MK_PARSER_fmtobj   MK_OBJN fmtobj __parser__(default=NULL)
 use param_fmtobj for documentation
 
native compiler definition
#define MK_CLRCALL
 
#define MK_STDCALL
 
#define MK_CDECL
 
#define mk_inline   static inline
 
#define mk_unlink   unlink
 
#define mk_snprintf   snprintf
 
#define MK_ATTR_HOT   __attribute__((hot))
 
#define MK_ATTR_COLD   __attribute__((cold))
 
#define MK_DECL   MK_STDCALL
 
#define BEGIN_MK_C_DECLS   namespace libmkkernel {
 
#define END_MK_C_DECLS   }
 
#define likely(x)
 
#define unlikely(x)
 
#define mk_timeval   timeval
 
#define mk_timezone   timezone
 
#define MK_UNUSED   __attribute__((unused))
 mark unnused variables and functions
 
#define MK_NO_RETURN   __attribute__((noreturn))
 dosable "MK_NO_RETURN" because C# require "return" from "MqExit" for thread-pool support
 
#define MK_UNREACHABLE   __builtin_unreachable()
 
#define MK_ARTIFICIAL   __attribute__((__artificial__))
 
#define MK_DEPRECATED   __attribute__ ((deprecated))
 
#define MK_OPTIMIZE_0   __attribute__((optimize("O0")))
 
META_HAS_THREAD
#define MkThreadLocal   __thread
 
#define MK_RT_SHIFT   1
 
#define MK_RT_ARGS_ONLY   MK_RT mkrt
 
#define MK_RT_ARGS   MK_RT_ARGS_ONLY,
 
#define MK_RT_CALL_ONLY   mkrt
 
#define MK_RT_CALL   MK_RT_CALL_ONLY,
 
#define MK_RT_CALL_O(o)
 
#define MK_RT_CALL_X(x)
 
#define MK_RT_CALL_NULL_ONLY   MkRT
 
#define MK_RT_CALL_NULL   MK_RT_CALL_NULL_ONLY,
 
#define MK_RT_NULL   NULL,
 
#define MK_RT_PTR   mkrt
 
#define MK_RT_REF   (*mkrt)
 
#define MK_RT_REF_NULL   (MkRuntimeRLS)
 
#define MK_RT_UNUSED   MK_UNUSED
 
#define MK_RT_CALL_RT(ptr)
 
#define MK_PARSER_RT_ONLY   MK_RT_ARGS_ONLY __parser__(internal,default=N#RUNTIME)
 
#define MK_PARSER_RT   MK_PARSER_RT_ONLY,
 
macros to support types
#define MkType_O   MK_BOL
 
#define MkType_Y   MK_I8
 
#define MkType_S   MK_I16
 
#define MkType_I   MK_I32
 
#define MkType_W   MK_I64
 
#define MkType_F   MK_FLT
 
#define MkType_D   MK_DBL
 
#define MkType_C   MK_STRN
 
#define MkType_B   MK_BIN
 
#define MkType_U   MK_BUF
 
#define MkType_L   MK_BFL
 
MkObjectC type check
#define __MkCheckTO(t, o)
 
#define _MkCheckTO(t, o)
 
#define __MkCheckO(cls, o)
 
#define _MkCheckO(cls, o)
 
#define __MkCheckX(cls, x)
 
#define _MkCheckX(cls, x)
 
#define __MkCheckM(cls, m)
 
#define _MkCheckM(cls, m)
 
#define MkCheckNN(cls, x)
 
#define MkSanitizeCheck(_root, _m)
 
#define MkSanitizeCheckO(_root, _o)
 
#define MkAssertO(cls, o)
 
#define MkAssertX(cls, x)
 
#define MkAssertCastM(cls, m)
 }
 
#define toTT(_type)
 
MkObjectC - signature define
#define MkObjectC_SIGNATURE   (0x59B3u<<16)
 
#define MkObjectC_MASK   (((1u<<16)-1)<<16)
 
MkObjectC - cast to superclass
#define MkObjectC_X2obj(x)
 
MkTypeC - signature define
#define MkTypeC_SIGNATURE   (MkObjectC_SIGNATURE ^ (11u<<10))
 
#define MkTypeC_MASK   (((1u<<22)-1)<<10)
 
MkTypeC - cast to superclass
#define MkTypeC_X2typ(x)
 
#define MkTypeC_X2obj(x)
 
MkTypeDefC - signature define
#define MkTypeDefC_SIGNATURE   (MkTypeC_SIGNATURE ^ (1u<<6))
 
#define MkTypeDefC_MASK   (((1u<<26)-1)<<6)
 
MkTypeDefC - cast to superclass
#define MkTypeDefC_X2typ(x)
 
#define MkTypeDefC_X2obj(x)
 
MkObjectC - MkObjectC_Obj_C_API - overload
#define MkRefCidN_NULL()
 
MkBufferC - signature define
#define MkBufferC_SIGNATURE   (MkObjectC_SIGNATURE ^ (1u<<10))
 
#define MkBufferC_MASK   (((1u<<22)-1)<<10)
 
MkBufferC - cast to superclass
#define MkBufferC_X2buf(x)
 
#define MkBufferC_X2obj(x)
 
MkBuffer64C - signature define
#define MkBuffer64C_SIGNATURE   (MkBufferC_SIGNATURE ^ (1u<<6))
 
#define MkBuffer64C_MASK   (((1u<<26)-1)<<6)
 
MkBuffer64C - cast to superclass
#define MkBuffer64C_X2buf(x)
 
#define MkBuffer64C_X2obj(x)
 
MkBuffer256C - signature define
#define MkBuffer256C_SIGNATURE   (MkBufferC_SIGNATURE ^ (2u<<6))
 
#define MkBuffer256C_MASK   (((1u<<26)-1)<<6)
 
MkBuffer256C - cast to superclass
#define MkBuffer256C_X2buf(x)
 
#define MkBuffer256C_X2obj(x)
 
MkBuffer1024C - signature define
#define MkBuffer1024C_SIGNATURE   (MkBufferC_SIGNATURE ^ (3u<<6))
 
#define MkBuffer1024C_MASK   (((1u<<26)-1)<<6)
 
MkBuffer1024C - cast to superclass
#define MkBuffer1024C_X2buf(x)
 
#define MkBuffer1024C_X2obj(x)
 
MkBuf2TTfast

MkBufferC - get a native PRIMITIVE TYPE from the MkBufferS

Attention
these function is only required in an non-alignment environment …
#define MkBuf2XXXfast(buf)
 
#define MkBuf2BOLfast(buf)
 
#define MkBuf2I8fast(buf)
 
#define MkBuf2I16fast(buf)
 
#define MkBuf2I32fast(buf)
 
#define MkBuf2I64fast(buf)
 
#define MkBuf2FLTfast(buf)
 
#define MkBuf2DBLfast(buf)
 
MkBuf2TT

get a native PRIMITIVE TYPE from a non-aligned MkBufferC

the alligned would be: ((*buf->storage.first.A).?)

#define MkBuf2XXX(xxx, len, buf)
 
#define MkBuf2BOL(buf)
 
#define MkBuf2I8(buf)
 
#define MkBuf2I16(buf)
 
#define MkBuf2I32(buf)
 
#define MkBuf2I64(buf)
 
#define MkBuf2FLT(buf)
 
#define MkBuf2DBL(buf)
 
#define MkBuf2Ptr(len, ptr, buf)
 
#define MkBuf2BOL_P(ptr, buf)
 
#define MkBuf2I8_P(ptr, buf)
 
#define MkBuf2I16_P(ptr, buf)
 
#define MkBuf2I32_P(ptr, buf)
 
#define MkBuf2I64_P(ptr, buf)
 
#define MkBuf2FLT_P(ptr, buf)
 
#define MkBuf2DBL_P(ptr, buf)
 
#define MkBuf2Ptr_A(l, a, b)
 
#define MkBuf2BOL_A(ato, buf)
 
#define MkBuf2I8_A(ato, buf)
 
#define MkBuf2I16_A(ato, buf)
 
#define MkBuf2I32_A(ato, buf)
 
#define MkBuf2I64_A(ato, buf)
 
#define MkBuf2FLT_A(ato, buf)
 
#define MkBuf2DBL_A(ato, buf)
 
MkBufferStreamC - signature define
#define MkBufferStreamC_SIGNATURE   (MkBufferC_SIGNATURE ^ (4u<<6))
 
#define MkBufferStreamC_MASK   (((1u<<26)-1)<<6)
 
MkBufferStreamC - cast to superclass
#define MkBufferStreamC_X2bus(x)
 
#define MkBufferStreamC_X2buf(x)
 
#define MkBufferStreamC_X2obj(x)
 
MkBufferStream64C - signature define
#define MkBufferStream64C_SIGNATURE   (MkBufferStreamC_SIGNATURE ^ (3u<<3))
 
#define MkBufferStream64C_MASK   (((1u<<29)-1)<<3)
 
MkBufferStream64C - cast to superclass
#define MkBufferStream64C_X2bus(x)
 
#define MkBufferStream64C_X2buf(x)
 
#define MkBufferStream64C_X2obj(x)
 
MkBufferStream256C - signature define
#define MkBufferStream256C_SIGNATURE   (MkBufferStreamC_SIGNATURE ^ (2u<<3))
 
#define MkBufferStream256C_MASK   (((1u<<29)-1)<<3)
 
MkBufferStream256C - cast to superclass
#define MkBufferStream256C_X2bus(x)
 
#define MkBufferStream256C_X2buf(x)
 
#define MkBufferStream256C_X2obj(x)
 
MkBufferStream1024C - signature define
#define MkBufferStream1024C_SIGNATURE   (MkBufferStreamC_SIGNATURE ^ (4u<<3))
 
#define MkBufferStream1024C_MASK   (((1u<<29)-1)<<3)
 
MkBufferStream1024C - cast to superclass
#define MkBufferStream1024C_X2bus(x)
 
#define MkBufferStream1024C_X2buf(x)
 
#define MkBufferStream1024C_X2obj(x)
 
MkBufferStream16384C - signature define
#define MkBufferStream16384C_SIGNATURE   (MkBufferStreamC_SIGNATURE ^ (1u<<3))
 
#define MkBufferStream16384C_MASK   (((1u<<29)-1)<<3)
 
MkBufferStream16384C - cast to superclass
#define MkBufferStream16384C_X2bus(x)
 
#define MkBufferStream16384C_X2buf(x)
 
#define MkBufferStream16384C_X2obj(x)
 
MkBufferStreamC - MkBufferStreamC_TOR_C_API - overload
#define MkBufferStreamCreate_1(size)
 
MkLogFileC - signature define
#define MkLogFileC_SIGNATURE   (MkObjectC_SIGNATURE ^ (3u<<10))
 
#define MkLogFileC_MASK   (((1u<<22)-1)<<10)
 
MkLogFileC - cast to superclass
#define MkLogFileC_X2lfl(x)
 
#define MkLogFileC_X2obj(x)
 
MkExtensionC - signature define
#define MkExtensionC_SIGNATURE   (MkObjectC_SIGNATURE ^ (9u<<10))
 
#define MkExtensionC_MASK   (((1u<<22)-1)<<10)
 
MkExtensionC - cast to superclass
#define MkExtensionC_X2ext(x)
 
#define MkExtensionC_X2obj(x)
 
MkErrorC - signature define
#define MkErrorC_SIGNATURE   (MkObjectC_SIGNATURE ^ (4u<<10))
 
#define MkErrorC_MASK   (((1u<<22)-1)<<10)
 
MkErrorC - cast to superclass
#define MkErrorC_X2err(x)
 
#define MkErrorC_X2obj(x)
 
MkErrExtC - signature define
#define MkErrExtC_SIGNATURE   (MkExtensionC_SIGNATURE ^ (1u<<6))
 
#define MkErrExtC_MASK   (((1u<<26)-1)<<6)
 
MkErrExtC - cast to superclass
#define MkErrExtC_X2errext(x)
 
#define MkErrExtC_X2ext(x)
 
#define MkErrExtC_X2obj(x)
 
MkErrorPanicC - signature define
#define MkErrorPanicC_SIGNATURE   (MkObjectC_SIGNATURE ^ (7u<<10))
 
#define MkErrorPanicC_MASK   (((1u<<22)-1)<<10)
 
MkErrorPanicC - cast to superclass
#define MkErrorPanicC_X2obj(x)
 
MkErrorExitC - signature define
#define MkErrorExitC_SIGNATURE   (MkObjectC_SIGNATURE ^ (8u<<10))
 
#define MkErrorExitC_MASK   (((1u<<22)-1)<<10)
 
MkErrorExitC - cast to superclass
#define MkErrorExitC_X2obj(x)
 
MkErrorIgnoreC - signature define
#define MkErrorIgnoreC_SIGNATURE   (MkObjectC_SIGNATURE ^ (5u<<10))
 
#define MkErrorIgnoreC_MASK   (((1u<<22)-1)<<10)
 
MkErrorIgnoreC - cast to superclass
#define MkErrorIgnoreC_X2obj(x)
 
MkErrorPrintC - signature define
#define MkErrorPrintC_SIGNATURE   (MkObjectC_SIGNATURE ^ (6u<<10))
 
#define MkErrorPrintC_MASK   (((1u<<22)-1)<<10)
 
MkErrorPrintC - cast to superclass
#define MkErrorPrintC_X2obj(x)
 
MkErrorDefaultC - signature define
#define MkErrorDefaultC_SIGNATURE   (MkErrorC_SIGNATURE ^ (1u<<6))
 
#define MkErrorDefaultC_MASK   (((1u<<26)-1)<<6)
 
MkErrorDefaultC - cast to superclass
#define MkErrorDefaultC_X2err(x)
 
#define MkErrorDefaultC_X2obj(x)
 
MkERROR

access the predefined error from MkRuntimeC as libmkkernel::MK_ERR

#define MkERROR_R(r)
 
#define MkERROR   MkERROR_R(&MK_RT_REF)
 
#define MkERROR_RT   MkERROR_R(&MK_RT_REF)
 
#define MkERROR_O(o)
 
#define MkERROR_X(x)
 
#define MkERROR_XN(x)
 
#define MkERROR_NULL   MkERROR_R(&MkRuntimeRLS)
 
MkErrorC - MkErrorC_Signal_C_API - overload
#define MkErrorSetCONTINUE_0E()
 
MkErrorCheck...

check on different aspects of an error …

Parameters
[in]mngxthe MkObjectS instance to work on
Returns
an boolean values… true or false
#define MkErrorCheckI(err)
 
MkErrorCheck
Returns
on libmkkernel::MK_OK and libmkkernel::MK_CONTINUE return 0 and an libmkkernel::MK_ERROR return 1
#define MkErrorCheckE_0E()
 
#define MkErrorCheckE_NULL()
 
#define MkErrorCheckE_O(o)
 
#define MkErrorCheckE_X(x)
 
#define MkErrorCheckE_E(e)
 
MkRtExtC - signature define
#define MkRtExtC_SIGNATURE   (MkExtensionC_SIGNATURE ^ (2u<<6))
 
#define MkRtExtC_MASK   (((1u<<26)-1)<<6)
 
MkRtExtC - cast to superclass
#define MkRtExtC_X2rtext(x)
 
#define MkRtExtC_X2ext(x)
 
#define MkRtExtC_X2obj(x)
 
MkRuntimeC - signature define
#define MkRuntimeC_SIGNATURE   (MkObjectC_SIGNATURE ^ (10u<<10))
 
#define MkRuntimeC_MASK   (((1u<<22)-1)<<10)
 
MkRuntimeC - cast to superclass
#define MkRuntimeC_X2rt(x)
 
#define MkRuntimeC_X2obj(x)
 
MkRtSetup
#define MkRT   (&MkRuntimeRLS)
 
#define MkRT_R   (MkRuntimeRLS)
 
#define MkRT_O(o)
 
#define MkRT_X(x)
 
#define MkRT_ONN(o)
 
#define MkRT_ON(o)
 
#define MkRT_XN(x)
 
#define MkRtSetup_O(o)
 
#define MkRtSetup_X(x)
 
#define MkRtSetup_XN(x)
 
#define MkRtSetup_ON(o)
 
#define MkRtSetup_NULL   MK_RT_UNUSED MK_RT const mkrt = MkRuntimeGet()
 
#define MkRtSetup_RT(r)
 
#define MkRtSetupFromRtExt(rtx)
 
#define MkRtSetup_O_RT(o)
 
#define MkRtSetup_ON_RT(o)
 
#define MkRtSetup_X_RT(x)
 
#define MkRtSetup_XN_RT(x)
 
#define MkRtSetup_NULL_RT   if (mkrt == NULL) mkrt = MkRuntimeGet()
 
#define AllRtSetup_O(o)
 
#define AllRtSetup_ON(o)
 
#define AllRtSetup_X(x)
 
#define AllRtSetup_XN(x)
 
#define AllRtSetup_NULL   MkRtSetup_NULL
 

Typedefs

typedef void * libmkkernel::MK_MACRO_TYP
 helper-type used to declare a prototype for a macro
 
typedef struct MkObjectSlibmkkernel::MK_OBJ
 class-shortcut for struct MkObjectS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkObjectSlibmkkernel::MK_OBJN
 class-shortcut for const struct MkObjectS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkObjectS libmkkernel::MK_OBJR
 reference-shortcut for struct MkObjectS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkBufferSlibmkkernel::MK_BUF
 class-shortcut for struct MkBufferS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkBufferSlibmkkernel::MK_BUFN
 class-shortcut for const struct MkBufferS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkBufferS libmkkernel::MK_BUFR
 reference-shortcut for struct MkBufferS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkBufferStreamSlibmkkernel::MK_BUS
 class-shortcut for struct MkBufferStreamS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkBufferStreamSlibmkkernel::MK_BUSN
 class-shortcut for const struct MkBufferStreamS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkBufferStreamS libmkkernel::MK_BUSR
 reference-shortcut for struct MkBufferStreamS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkBufferListSlibmkkernel::MK_BFL
 class-shortcut for struct MkBufferListS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkBufferListSlibmkkernel::MK_BFLN
 class-shortcut for const struct MkBufferListS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkBufferListS libmkkernel::MK_BFLR
 reference-shortcut for struct MkBufferListS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkLogFileSlibmkkernel::MK_LFL
 class-shortcut for struct MkLogFileS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkLogFileSlibmkkernel::MK_LFLN
 class-shortcut for const struct MkLogFileS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkLogFileS libmkkernel::MK_LFLR
 reference-shortcut for struct MkLogFileS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkErrorSlibmkkernel::MK_ERR
 class-shortcut for struct MkErrorS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkErrorSlibmkkernel::MK_ERRN
 class-shortcut for const struct MkErrorS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkErrorS libmkkernel::MK_ERRR
 reference-shortcut for struct MkErrorS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkExtensionSlibmkkernel::MK_EXT
 class-shortcut for struct MkExtensionS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkExtensionSlibmkkernel::MK_EXTN
 class-shortcut for const struct MkExtensionS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkExtensionS libmkkernel::MK_EXTR
 reference-shortcut for struct MkExtensionS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkErrExtSlibmkkernel::MK_ERREXT
 class-shortcut for struct MkErrExtS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkErrExtSlibmkkernel::MK_ERREXTN
 class-shortcut for const struct MkErrExtS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkErrExtS libmkkernel::MK_ERREXTR
 reference-shortcut for struct MkErrExtS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkRtExtSlibmkkernel::MK_RTEXT
 class-shortcut for struct MkRtExtS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkRtExtSlibmkkernel::MK_RTEXTN
 class-shortcut for const struct MkRtExtS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkRtExtS libmkkernel::MK_RTEXTR
 reference-shortcut for struct MkRtExtS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkRuntimeSlibmkkernel::MK_RT
 class-shortcut for struct MkRuntimeS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkRuntimeSlibmkkernel::MK_RTN
 class-shortcut for const struct MkRuntimeS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkRuntimeS libmkkernel::MK_RTR
 reference-shortcut for struct MkRuntimeS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkTypeSlibmkkernel::MK_TYP
 class-shortcut for struct MkTypeS *, all shortcut using the XX_YYY syntax (only for public API) …
 
typedef const struct MkTypeSlibmkkernel::MK_TYPN
 class-shortcut for const struct MkTypeS *, all const shortcut using the XX_YYYC syntax (only for public API) …
 
typedef struct MkTypeS libmkkernel::MK_TYPR
 reference-shortcut for struct MkTypeS, all shortcut using the XX_YYYR syntax (only for public API) …
 
typedef struct MkBufferListSlibmkkernel::MK_BAC
 a list of 'buffer' as last argument in function …
 
typedef const struct MkBufferListSlibmkkernel::MK_BACN
 const - a list of 'buffer' as last argument in function …
 
typedef uintptr_t libmkkernel::MK_IDNT
 process or thread identifier …
 
typedef MK_PTR(* libmkkernel::MkCacheCF) (MK_RT mkrt, MK_PTR const)
 
typedef void(* libmkkernel::MkCacheDF) (MK_RT mkrt, MK_PTR *const)
 
typedef void(* libmkkernel::MkMarkF) (MK_RT mkrt, MK_PTR data)
 prototype for a Garbage-Collection mark function …
 
typedef MK_PTR(* libmkkernel::MkSysCallocF) (size_t, size_t)
 calloc syscall …
 
typedef MK_PTR(* libmkkernel::MkSysMallocF) (size_t)
 malloc syscall …
 
typedef MK_STR(* libmkkernel::MkSysStrDupF) (MK_STRN)
 strdup syscall …
 
typedef MK_STR(* libmkkernel::MkSysStrNCpyF) (char *, const char *, size_t)
 strdup strncpy …
 
typedef MK_STR(* libmkkernel::MkSysStrNDupF) (MK_STRN, size_t)
 strndup syscall …
 
typedef MK_PTR(* libmkkernel::MkSysReallocF) (MK_PTR, size_t)
 realloc syscall …
 
typedef void(* libmkkernel::MkSysFreeF) (MK_PTR)
 free syscall …
 
typedef pid_t(* libmkkernel::MkSysForkF) (void)
 fork syscall …
 
typedef enum MkErrorE(* libmkkernel::MkSysWaitF) (MK_OBJN const fmtobj, MK_IDNT const id)
 wait for process to finish syscall with ccmkkernel error plugin
 
typedef int(* libmkkernel::MkSysExitF) (MK_RT mkrt, int isThread, int num)
 
typedef enum libmkkernel::MkSysPipeHandlerE libmkkernel::MkSysPipeHandlerE
 
typedef enum MkErrorE(* libmkkernel::MkObjectDeleteCallF) (MK_RT mkrt, MK_OBJN const obj, MK_STRN const typeName, MK_HDL const typeHdl, MK_HDL const objHdl, MK_CBP const __data__)
 static callback to delete an obj
 
typedef void(* libmkkernel::MkObjectDeleteFreeF) (MkObjectDeleteFreeF_ARGS)
 
typedef struct MkBufferStream16384S libmkkernel::MkBufferStream16384R
 reference type of MkBufferStream16384S
 
typedef struct libmkkernel::MkLogDataS libmkkernel::MkLogDataS
 struct to hold the mkrt-logging-data
 
typedef struct libmkkernel::MkExtensionS libmkkernel::MkExtensionS
 Base class for the extension technologie …
 
typedef bool(* libmkkernel::MkErrorAppendFLT) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)
 
typedef void(* libmkkernel::MkErrorResetF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)
 
typedef bool(* libmkkernel::MkErrorResetOnExitF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)
 
typedef void(* libmkkernel::MkErrorPanikF) (MK_ERREXT_ARGS_N, MK_OBJN const errobj, MK_STRN const prefix, MK_I32 const errnum, MK_STRN const fmt, va_list ap)
 MK_OBJN const errobj because of MK_ERROR_FORMAT value.
 
typedef void(* libmkkernel::MkErrorLogF) (MK_ERREXT_ARGS_N, MK_OBJN const, MK_DBG const, MK_STRN const, MK_I32 const, MK_STRN const, MK_OBJ const)
 
typedef MK_OBJN(* libmkkernel::MkErrorFormatOfF) (MK_ERREXT_ARGS_N, int const dummy)
 
typedef void(* libmkkernel::MkErrorSetRF) (MK_ERREXT_ARGS, MK_MNGN const errctx, MK_OBJN const fmtobj)
 
typedef void(* libmkkernel::MkErrorSetEF) (MK_ERREXT_ARGS, MK_ERREXT const newerr, MK_OBJN const fmtobj)
 
typedef bool(* libmkkernel::MkErrorSetVLF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj, MK_STRN const)
 
typedef void(* libmkkernel::MkErrorInit) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)
 
typedef struct libmkkernel::MkThreadDataS libmkkernel::MkThreadDataS
 
typedef void(* libmkkernel::MkRuntimeInitF) (MK_RT mkrt)
 additional runtime initialization function …
 
signed integer data-type
typedef signed char libmkkernel::MK_I8
 1 byte byte data-type
 
typedef signed short int libmkkernel::MK_I16
 2 byte short data-type
 
typedef signed int libmkkernel::MK_I32
 4 byte integer data-type
 
typedef signed long long libmkkernel::MK_I64
 8 byte wide integer data-type
 
typedef long libmkkernel::MK_LONG
 4/8 byte long data-type
 
unsigned integer data-type
typedef unsigned char libmkkernel::MK_U8
 
typedef unsigned short libmkkernel::MK_U16
 
typedef unsigned int libmkkernel::MK_U32
 
typedef unsigned long long libmkkernel::MK_U64
 
typedef unsigned long libmkkernel::MK_ULN
 
float data-type
typedef float libmkkernel::MK_FLT
 4 byte float data-type
 
typedef double libmkkernel::MK_DBL
 8 byte double data-type
 
pointer data-type
typedef void libmkkernel::MK_PTRB
 pointer type data-type
 
typedef MK_PTRBlibmkkernel::MK_PTR
 generic pointer data-type
 
typedef const MK_PTRBlibmkkernel::MK_PTRN
 const generic pointer data-type
 
typedef MK_PTRBlibmkkernel::MK_CCP
 class constructor/destructor data type
 
typedef MK_PTRBlibmkkernel::MK_CBP
 generic pointer to call-back data
 
typedef MK_PTRBlibmkkernel::MK_MNG
 managed object pointer, datatype will be checked at runtime
 
typedef const MK_PTRBlibmkkernel::MK_MNGN
 const - a managed object pointer, datatype will be checked at runtime
 
typedef MK_PTRB const * libmkkernel::MK_EXP
 exception object pointer
 
typedef MK_PTRBlibmkkernel::MK_MXP
 MkExceptionC object pointer.
 
list data-type
typedef unsigned char libmkkernel::MK_LSTB
 list type data-type
 
typedef MK_LSTBlibmkkernel::MK_LST
 list pointer data-type
 
binary data-type
typedef unsigned char libmkkernel::MK_BINB
 byte-array type data-type
 
typedef MK_BINBlibmkkernel::MK_BIN
 byte-array pointer data-type with binary encoding (MK_BINN)
 
typedef MK_BINB const * libmkkernel::MK_BINN
 const byte-array pointer data-type
 
helper type for target language implementation
typedef void * libmkkernel::MK_NAT_OBJECT
 
typedef void * libmkkernel::MK_NAT_LIST
 
MkObjectC slot definition
typedef MK_OBJ(* libmkkernel::MkConstructorF) (MK_RT mkrt, MK_TYP type, MK_PTR nat, MK_PTR lnk)
 
typedef void(* libmkkernel::MkDestructorF) (MK_RT mkrt, MK_OBJ const obj)
 
typedef MK_OBJ(* libmkkernel::MkDupF) (MK_RT mkrt, MK_OBJN const obj)
 
typedef MK_OBJ(* libmkkernel::MkDup2F) (MK_RT mkrt, MK_OBJN const obj, MK_STRN const ident)
 
typedef MK_OBJ(* libmkkernel::MkMergeF) (MK_RT mkrt, MK_OBJ const obj)
 
typedef MK_OBJ(* libmkkernel::MkCopyF) (MK_RT mkrt, MK_OBJ const obj, MK_OBJN const src)
 
typedef MK_OBJ(* libmkkernel::MkResetF) (MK_RT mkrt, MK_OBJ const obj)
 
typedef MK_PTR(* libmkkernel::MkSelfCreateF) (MK_RT mkrt, MK_OBJ const obj, MK_PTR const env)
 
typedef void(* libmkkernel::MkSelfDeleteF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)
 
typedef void(* libmkkernel::MkSelfUnlinkF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)
 
typedef void(* libmkkernel::MkLogF) (MK_RT mkrt, MK_OBJN const obj, MK_OBJN fmt, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 
typedef MK_STRN(* libmkkernel::MkToStringF) (MK_RT mkrt, MK_OBJN const obj)
 
typedef MK_PTR(* libmkkernel::MkAllocCreateFLT) (MK_RT mkrt, MK_TYP const type)
 
typedef void(* libmkkernel::MkAllocDeleteF) (MK_RT mkrt, MK_TYP const type, MK_PTR ptr)
 
typedef void(* libmkkernel::MkTypeInitF) (MK_RT mkrt, MK_TYP const type)
 
typedef bool(* libmkkernel::MkLogFormatF) (MK_RT mkrt, char *header, MK_SIZE const headerSize, MK_OBJN const obj, MK_STRN const caller, MK_I32 const debug, MK_STRN const fmt)
 

Enumerations

enum  libmkkernel::MkIdSE { libmkkernel::MK_ID_UNUSED = 0 , libmkkernel::MK_ID_PROCESS = 1 , libmkkernel::MK_ID_THREAD = 2 }
 signal type of the MkIdS data valMore...
 
enum  libmkkernel::MkSysPipeHandlerE { libmkkernel::MK_PIPE_KEEP = 0 , libmkkernel::MK_PIPE_IGNORE = 1 }
 

Functions

static MkBinaryR libmkkernel::MkBinaryCreate (MK_SIZE size, MK_BINN data)
 create a binary from data and size ...
 
static bool libmkkernel::MkBinaryIsNull (const MkBinaryR bin)
 check if binary is NULL ...
 
static const MkBinaryR libmkkernel::MkBinaryCreateSlice (const MkBinaryR bin, MK_SIZE start, MK_SIZE wide)
 create a binary slice ...
 
static MkBinaryR libmkkernel::MkBinaryDup_RT (MK_RT mkrt, const MkBinaryR bin)
 create a binary as duplicate from an already existsing MkBinaryR ...
 
static void libmkkernel::MkBinaryLog_RT (MK_RT mkrt, const MkBinaryR bin)
 get size from the binary ...
 
static MK_BINN libmkkernel::MkBinaryGetData (const MkBinaryR bin)
 get data pointer from the binary ...
 
static MK_SIZE libmkkernel::MkBinaryGetSize (const MkBinaryR bin)
 get size from the binary ...
 
static void libmkkernel::MkStringLog_RT (MK_RT mkrt, MkStringR const str, MK_STRN func)
 log the string ...
 
static MkStringR libmkkernel::MkStringCreate (MK_NUM len, MK_STRN str)
 create a str from ptr and len ...
 
static MkStringR libmkkernel::MkStringCreate_1 (MK_STRN str)
 create a str from ptr use MK_NULL as end-of-string ...
 
static MkStringR libmkkernel::MkStringSlice (MkStringR strR, MK_NUM start, MK_NUM len)
 create a slice of strR start at start with max len bytes …
 
static void libmkkernel::MkStringSplit (MkStringR strR, MK_NUM *len_out, MK_STRN *str_out)
 split a str into ptr and len
 
static MkStringR libmkkernel::MkStringDup_RT (MK_RT mkrt, MkStringR const str)
 create a string as duplicate from an already existsing MkBinaryR ...
 
static MK_STRN libmkkernel::MkStringGetData (MkStringR const str)
 get ptr pointer from the string ...
 
static MK_NUM libmkkernel::MkStringGetSize (MkStringR const str)
 get len from the string ...
 
static bool libmkkernel::MkStringIsNULL (MkStringR const strR)
 check if strR is MK_NULL_STR return true or false
 
MK_STRN libmkkernel::MkIdSE_ToString (enum MkIdSE value)
 return the MkIdSE as string …
 
static MK_I32 libmkkernel::MkIdSE_ToInt (enum MkIdSE value)
 return the MkIdSE as integer …
 
enum MkErrorE libmkkernel::MkIdSE_FromInt (MK_I32 const value, enum MkIdSE *value_out)
 return the MkIdSE from integer …
 
void libmkkernel::MkSetup (void)
 setup ccmkkernel internal memory …
 
void libmkkernel::MkCleanup (void)
 cleanup ccmkkernel internal memory …
 
bool libmkkernel::MkHasThread (void)
 
bool libmkkernel::MkHasFork (void)
 
MK_PTR libmkkernel::MkSysCalloc (MK_OBJN fmtobj, size_t const nmemb, size_t const size)
 calloc syscall with ccmkkernel error plugin
 
MK_PTR libmkkernel::MkSysMalloc (MK_OBJN fmtobj, size_t const size)
 malloc syscall with ccmkkernel error plugin
 
MK_STR libmkkernel::MkSysStrDup (MK_OBJN fmtobj, MK_STRN const str)
 strdup syscall with ccmkkernel error plugin
 
MK_STR libmkkernel::MkSysStrNDup (MK_OBJN fmtobj, MK_STRN const str, MK_SIZE const len)
 strndup syscall with ccmkkernel error plugin
 
enum MkErrorE libmkkernel::MkSysStrNCpy (MK_OBJN fmtobj, MK_STR const to, MK_STRN const from, MK_SIZE const len)
 strncpy syscall with ccmkkernel error plugin
 
MK_PTR libmkkernel::MkSysRealloc (MK_OBJN fmtobj, MK_PTR const buf, size_t const size)
 realloc syscall with ccmkkernel error plugin
 
MK_PTR libmkkernel::MkSysReCalloc (MK_OBJN fmtobj, MK_PTR const buf, MK_NUM const oldnum, MK_NUM const addnum, size_t const size)
 realloc syscall with ccmkkernel error plugin
 
MK_PTR libmkkernel::MkSysMemDup (MK_OBJN fmtobj, MK_PTRN const blck, size_t const size)
 memdup syscall with ccmkkernel error plugin
 
MK_STRN_A libmkkernel::MkSysStringArrayDup (MK_OBJN fmtobj, MK_STRN_A const strA)
 strdup syscall with ccmkkernel error plugin
 
void libmkkernel::MkSysFree (MK_PTR pointer)
 free syscall …
 
void libmkkernel::MkSysFreeNonNull (MK_PTR pointer)
 
void libmkkernel::MkSysFreeP (MK_PTR data)
 free syscall with ccmkkernel error plugin
 
void libmkkernel::MkSysPrintStackTrace_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_I32 const debug, MK_STRN const callfunc, MK_I32 const lvl, MK_I32 skip, MK_I32 const num)
 backtrace syscall with ccmkkernel error plugin
 
void libmkkernel::MkSysPrintProcessMemoryMap_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_I32 const debug, MK_STRN const callfunc, MK_I32 const lvl)
 write the memory-map to MkLogFileC used at MkDisasterSignal
 
MK_STRN libmkkernel::MkSysGetTrace_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_I32 const debug, MK_STRN const callfunc, MK_I32 const lvl, MK_I32 skip, MK_I32 const num)
 same as MkSysPrintStackTrace but return a string…
 
static enum MkErrorE libmkkernel::MkSysWaitForProcess (MK_OBJN fmtobj, MK_IDNT const id)
 wait for process to finish syscall with ccmkkernel error plugin
 
static enum MkErrorE libmkkernel::MkSysWaitForThread (MK_OBJN fmtobj, MK_IDNT const id)
 wait for thread to finish syscall with ccmkkernel error plugin
 
static enum MkErrorE libmkkernel::MkSysUSleep (MK_OBJN fmtobj, useconds_t const usec)
 usleep syscall with ccmkkernel error plugin
 
static enum MkErrorE libmkkernel::MkSysSleep (MK_OBJN fmtobj, MK_I32 const sec)
 sleep syscall with ccmkkernel error plugin
 
static int libmkkernel::MkSysExit_RT (MK_RT mkrt, int isThread, int num)
 exit syscall with ccmkkernel error plugin
 
MK_STR libmkkernel::MkSysBasename_RT (MK_RT mkrt, MK_STRN const pathName, bool const includeExtension)
 basename syscall with ccmkkernel error plugin
 
MK_STR libmkkernel::MkSysDirname_RT (MK_RT mkrt, MK_STRN const pathName)
 dirname syscall with ccmkkernel error plugin
 
MK_STR libmkkernel::MkSysPrintF_RT (MK_RT mkrt, MK_STRN const format,...)
 sprintf syscall with ccmkkernel error plugin
 
enum MkErrorE libmkkernel::MkSysGetTimeOfDay (MK_OBJN fmtobj, struct mk_timeval *tv_out, struct mk_timezone *tz_out)
 gettimeofday syscall with ccmkkernel error plugin
 
bool libmkkernel::MkSysStringSetNULL_R (MK_STRN const str)
 set string to EMPTY
 
bool libmkkernel::MkSysStringSet_R (MK_STRN const str, MK_STRN const other)
 set string to value
 
bool libmkkernel::MkSysStringIsNULL_R (MK_STRN const str)
 test if string EMPTY
 
static bool libmkkernel::MkSysStringIsNULL (MK_STRN str)
 test if string is NULL or EMPTY
 
static bool libmkkernel::MkSysStringIsNotNULL (MK_STRN str)
 test if string is NOT NULL or EMPTY
 
bool libmkkernel::MkSysStringIsEQUAL (MK_STRN const str, MK_STRN const other)
 test if string(s) are equal …
 
bool libmkkernel::MkSysStringIsLenEQUAL (MK_STRN const str, MK_STRN const other, MK_SIZE const len)
 test if string(s) are equal …
 
static MK_STRN libmkkernel::MkSysStringGet (MK_STRN str)
 get string NULL or VALUE
 
static MK_STRN libmkkernel::MkSysStringGetNoNULL (MK_STRN str)
 get string "" or VALUE
 
MK_STRN libmkkernel::MkSysHashSTR (MK_STRN key, MK_NUM length)
 compute the HASH from a string …
 
MK_I32 libmkkernel::MkSysHashI32 (MK_STRN key, MK_NUM length)
 same as MkSysHashSTR but return libmkkernel::MK_I32
 
enum MkErrorE libmkkernel::MkSysKill (MK_OBJN fmtobj, MK_I32 pid, MK_I32 signal)
 kill syscall with ccmkkernel error plugin
 
enum MkErrorE libmkkernel::MkSysGetPid (MK_OBJN fmtobj, MK_I32 *pid_out)
 getpid syscall with ccmkkernel error plugin
 
void libmkkernel::MkSysPipeHandler (MkSysPipeHandlerE keepPipe)
 internal support for pipe ignore
 
static MK_TYP libmkkernel::MkTyp (const MK_MNG mng)
 type-check and cast a unknown-managed-object into an MkTypeS pointer or MK_NULL if not possible
 
static MK_TYPN libmkkernel::MkTypN (const MK_MNGN mng)
 type-check and cast a unknown-managed-object into an MkTypeS pointer or MK_NULL if not possible
 
MK_PTR libmkkernel::MkTypeSlotResolveP (MK_RT mkrt, MK_TYPN const type, size_t const offset, bool const force)
 hidden function for MkTypeSlotResolve
 
MK_OBJ libmkkernel::MkObjDup_RT (MK_RT mkrt, MK_OBJ const srcobj)
 call the Dup-Constructor from the object
 
MK_OBJ libmkkernel::MkObjDup2_RT (MK_RT mkrt, MK_OBJ const srcmng, MK_STRN const ident)
 call the Dup2-Constructor from the object
 
MK_OBJ libmkkernel::MkObjMerge_RT (MK_RT mkrt, MK_OBJ const obj)
 Constructor - create a new object as a merge from an existing object
 
MK_OBJ libmkkernel::MkObjCreate_RT (MK_RT mkrt, MK_TYP type, MK_PTR nat, MK_PTR lnk)
 call the Constructor from the object
 
void libmkkernel::MkObjectDelete_RT (MK_RT mkrt, MK_OBJ obj)
 Delete-Slot - delete an instance.
 
void libmkkernel::MkObjectDispose_RT (MK_RT mkrt, MK_OBJ obj)
 Dispose-Slot - untie the connection between the Native-C++-Instance and the ccmkkernel-Instance.
 
enum MkErrorE libmkkernel::MkObjectDeleteCallbackSetup_RT (MK_RT mkrt, MK_STRN ident, MkObjectDeleteCallF fCall, MK_CBP callback, MkObjectDeleteFreeF fFree, MK_STRN filter)
 Create/Delete the instance-delete-callback
 
void libmkkernel::MkObjectDeleteCallbackCleanup_RT (MK_RT mkrt, MK_STRN ident)
 cleanup the DeleteCallback installed with MkObjectDeleteCallbackSetup
 
MK_OBJ libmkkernel::MkObjCopy_RT (MK_RT mkrt, MK_OBJ const tgtmng, MK_OBJN const srcmng)
 call the copy from the object
 
MK_OBJ libmkkernel::MkObjReset_RT (MK_RT mkrt, MK_OBJ const obj)
 free the internal memory of an object and initialize the local variables to default values
 
MK_TYP libmkkernel::MkTypeCreate (MK_MACRO_TYP const clsV, MK_MACRO_TYP const basicV, MK_STRN const identV)
 create a new type …
 
MK_TYP libmkkernel::MkTypeDup2_RT (MK_RT mkrt, MK_TYPN const typ, MK_STRN const ident)
 duplicate typ to create a lightweight-type
 
MK_OBJ libmkkernel::MkTypeAlloc_RT (MK_RT mkrt, MK_TYPN const typ)
 alloc instance-memory for MkTypeS
 
MK_TYP libmkkernel::MkTypeResolve_RT (MK_RT mkrt, MK_TYPN const typ)
 resolve a new type
 
void libmkkernel::MkTypeDelete_RT (MK_RT mkrt, MK_TYP const typ)
 delete a type object
 
static MK_OBJ libmkkernel::MkTypeInstances (MK_TYP const typ)
 access the instance attribute of the type…
 
static MK_TYPN libmkkernel::MkTypeNextN (MK_TYPN const typ)
 get next instance from linked-list of MkObjectS type
 
void libmkkernel::MkTypeLog_RT (MK_RT mkrt, MK_TYPN const typ, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the MkTypeS
 
MK_BFL libmkkernel::MkKernelGetTypeList_RT (MK_RT mkrt)
 return a list of all types defind in the Programming-Language-Micro-Kernel (PLMK)
 
MK_STRN const libmkkernel::MkObjectToName_RT (MK_RT mkrt, MK_OBJN const obj)
 Info-Slot - returns brief information about the obj as a string
 
MK_STRN libmkkernel::MkObjectToNameOfType_RT (MK_RT mkrt, MK_OBJN const obj)
 Type-Slot - returns the LibMkKernel-Type-Name of the obj as a string
 
MK_STRN libmkkernel::MkObjectToNameOfClass_RT (MK_RT mkrt, MK_OBJ const obj)
 Class-Slot - returns the C++-Class-Name of the obj as string
 
MK_STRN libmkkernel::MkObjectToString_RT (MK_RT mkrt, MK_OBJN const inst)
 String-Slot - returns the string representation of the inst
 
static bool libmkkernel::MkObjectIsNull (MK_OBJ const obj)
 ckeck if the object is MK_NULL
 
void libmkkernel::MkLogC_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const message, MK_DBG const debug, MK_STRN const callfunc)
 write a logging-message to MkLogFileC (default: stderr) using the internal format …
 
void libmkkernel::MkDbgV_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc, FILE *FH, MK_FST const printfmt,...)
 write a printf style debug-message to FH using the internal format …
 
void libmkkernel::MkLogV_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc, MK_DBG debug, MK_FST const printfmt,...)
 write a printf style logging-message to MkLogFileC (default: stderr) using the internal format …
 
void libmkkernel::MkLogVL_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc, MK_DBG debug, MK_FST const printfmt, va_list var_list)
 write a vprintf style logging-message to MkLogFileC using the internal format …
 
void libmkkernel::MkLogHEX_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc, MkBinaryR const data)
 log binaray data as HEX into the MkLogFileC (default: stderr) …
 
void libmkkernel::MkObjectLogShort_RT (MK_RT mkrt, MK_OBJN const obj, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the MkObjectS into the MkLogFileC (default: stderr) …
 
void libmkkernel::MkObjectLogLong_RT (MK_RT mkrt, MK_OBJN const obj, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the MkObjectS verbose into the MkLogFileC (default: stderr) …
 
void libmkkernel::MkObjectLogType_RT (MK_RT mkrt, MK_OBJN const obj, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the tyoe of the MkObjectS into the MkLogFileC (default: stderr) …
 
void libmkkernel::MkObjectLog_RT (MK_RT mkrt, MK_OBJN const obj, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 Log-Slot - log a summary of an object to the MkLogFileC (default: stderr) target …
 
void libmkkernel::MkDbgL_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const message, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 debug: write a instance-marker to the MkLogFileC (default: stderr) using the fmtobj as prefix …
 
enum MkErrorE libmkkernel::MkDbgDump_RT (MK_RT mkrt, MK_OBJN const obj, MK_STRN const message, MK_STRN const callfunc)
 debug: Dump a instance to stderr with LNG and MQ internal data…
 
void libmkkernel::MkDbgM_RT (MK_RT mkrt, MK_STRN const message, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 debug: write a static-marker to the MkLogFileC (default: stderr) …
 
void libmkkernel::MkDbgSTACK_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_I32 const skip, MK_I32 const num, MK_STRN const callfunc)
 debug: write the stack-trace to MkLogFileC (default: stderr) …
 
void libmkkernel::MkDbgO_RT (MK_RT mkrt, MK_OBJN const obj, MK_STRN const callfunc)
 debug: write the object-details to MkLogFileC (default: stderr) …
 
void libmkkernel::MkDbgLogC_RT (MK_RT mkrt, MK_OBJN const obj, MK_STRN const callfunc)
 debug: write a short-obj-summary to MkLogFileC (default: stderr) …
 
MK_BUF libmkkernel::MkBufferCreate_RT (MK_RT mkrt, MK_TYP type, MK_NUM const size)
 Constructor - create a new MkBufferC with minimum size of internal storage …
 
MK_BUF libmkkernel::MkBufferCreate64_RT (MK_RT mkrt, MK_NUM const size)
 call the BufferCreate with default type MkBuffer64S (64 byte) …
 
MK_BUF libmkkernel::MkBufferCreate256_RT (MK_RT mkrt, MK_NUM const size)
 call the BufferCreate with default type MkBuffer256S (256 byte) …
 
MK_BUF libmkkernel::MkBufferCreate1024_RT (MK_RT mkrt, MK_NUM const size)
 call the BufferCreate with default type MkBuffer1024S (1024 byte) …
 
void libmkkernel::MkBufferCreateTLS_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size)
 
void libmkkernel::MkBufferCreateTLS_inout_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_BUF *inout)
 
void libmkkernel::MkBufferCreateLOCAL_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size)
 
MK_BUF libmkkernel::MkBufferCreateI8_RT (MK_RT mkrt, MK_I8 const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateBOL_RT (MK_RT mkrt, MK_BOL const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateI16_RT (MK_RT mkrt, MK_I16 const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateI32_RT (MK_RT mkrt, MK_I32 const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateFLT_RT (MK_RT mkrt, MK_FLT const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateI64_RT (MK_RT mkrt, MK_I64 const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateDBL_RT (MK_RT mkrt, MK_DBL const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateSTR_RT (MK_RT mkrt, MK_STRN const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateBIN_RT (MK_RT mkrt, MkBinaryR const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
MK_BUF libmkkernel::MkBufferCreateTLS_RT (MK_RT mkrt, MK_STRN const tlsName, bool const resetB)
 same as BufferCreate but require no cleanup
 
MK_BUF libmkkernel::MkBufferCreateBUF_RT (MK_RT mkrt, MK_BUFN const val)
 Constructor - create a new MkBufferC with an PRIMITIVE TYPE
 
void libmkkernel::MkBufferFree_RT (MK_RT mkrt, MK_BUF const buf)
 initialize or free an MkBufferC reference-instance
 
void libmkkernel::MkBufferInit_RT (MK_RT mkrt, MK_BUF const buf, MK_TYP type, MK_NUM const size)
 initialize or free an MkBufferC reference-instance
 
void libmkkernel::MkBufferDelete_RT (MK_RT mkrt, MK_BUF const buf)
 Destructor - delete a MkBufferC instance …
 
MK_BUF libmkkernel::MkBufferDup_RT (MK_RT mkrt, MK_BUFN const buf)
 Dup-Constructor - create a new MkBufferC instance as copy from an existing MkBufferC instance
 
MK_BUF libmkkernel::MkBufferMerge_RT (MK_RT mkrt, MK_BUF const buf)
 Merge-Constructor - create a new MkBufferC as a merge from an existing object …
 
enum MkErrorE libmkkernel::MkBufferGetI8_RT (MK_RT mkrt, MK_BUFN const buf, MK_I8 *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetBOL_RT (MK_RT mkrt, MK_BUFN const buf, MK_BOL *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetI16_RT (MK_RT mkrt, MK_BUFN const buf, MK_I16 *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetU16_RT (MK_RT mkrt, MK_BUFN const buf, MK_U16 *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetI32_RT (MK_RT mkrt, MK_BUFN const buf, MK_I32 *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetU32_RT (MK_RT mkrt, MK_BUFN const buf, MK_U32 *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetFLT_RT (MK_RT mkrt, MK_BUFN const buf, MK_FLT *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetI64_RT (MK_RT mkrt, MK_BUFN const buf, MK_I64 *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetDBL_RT (MK_RT mkrt, MK_BUFN const buf, MK_DBL *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetBIN_RT (MK_RT mkrt, MK_BUFN const buf, MkBinaryR *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetSTR_RT (MK_RT mkrt, MK_BUFN const buf, MK_STRN *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetStringR_RT (MK_RT mkrt, MK_BUFN const buf, MkStringR *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetBUF_RT (MK_RT mkrt, MK_BUF const buf, MK_BUF *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetBFL_RT (MK_RT mkrt, MK_BUFN const buf, MK_BFL *const val_inout)
 function to read an MkBufferListC from an MkBufferC object …
 
enum MkErrorE libmkkernel::MkBufferGetLONG_RT (MK_RT mkrt, MK_BUFN const buf, MK_LONG *const val_out)
 get a val_out from a MkBufferC
 
enum MkErrorE libmkkernel::MkBufferGetBOOL_RT (MK_RT mkrt, MK_BUFN const buf, MK_BOOL *const val_out)
 get a val_out from a MkBufferC
 
MK_BUF libmkkernel::MkBufferSetI8_RT (MK_RT mkrt, MK_BUF const buf, MK_I8 const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetBOL_RT (MK_RT mkrt, MK_BUF const buf, MK_BOL const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetI16_RT (MK_RT mkrt, MK_BUF const buf, MK_I16 const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetI32_RT (MK_RT mkrt, MK_BUF const buf, MK_I32 const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetFLT_RT (MK_RT mkrt, MK_BUF const buf, MK_FLT const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetI64_RT (MK_RT mkrt, MK_BUF const buf, MK_I64 const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetDBL_RT (MK_RT mkrt, MK_BUF const buf, MK_DBL const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetSTR_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetBIN_RT (MK_RT mkrt, MK_BUF const buf, MkBinaryR const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetBUF_RT (MK_RT mkrt, MK_BUF const buf, MK_BUFN const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetVL_RT (MK_RT mkrt, MK_BUF const buf, MK_FST const val, va_list var_list)
 set the MkBufferC using a va_list value …
 
MK_BUF libmkkernel::MkBufferSetV_RT (MK_RT mkrt, MK_BUF const buf, MK_FST const val,...)
 set the MkBufferC using a ... value …
 
MK_BUF libmkkernel::MkBufferSetBinaryR_RT (MK_RT mkrt, MK_BUF const buf, MkBinaryR const val)
 Set the MkBufferC to the val
 
MK_BUF libmkkernel::MkBufferSetStringR_RT (MK_RT mkrt, MK_BUF const buf, MkStringR const val)
 Set the MkBufferC to the val
 
MK_STRB libmkkernel::MkBufferGetType1_RT (MK_RT mkrt, MK_BUFN const buf)
 return the type from a MkBufferC as single character value …
 
enum MkTypeE libmkkernel::MkBufferGetType2_RT (MK_RT mkrt, MK_BUFN const buf)
 return the MkTypeE from a MkBufferC
 
MK_STRN libmkkernel::MkBufferGetType3_RT (MK_RT mkrt, MK_BUFN const buf)
 return the type from a MkBufferC as single character string …
 
bool libmkkernel::MkBufferIsLocal_RT (MK_RT mkrt, MK_BUFN const buf)
 Check if the MkBufferC is local (temporary), not local mean global
 
void libmkkernel::MkBufferLog_RT (MK_RT mkrt, MK_BUFN const buf, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the MkBufferC
 
void libmkkernel::MkBufferLogSS_RT (MK_RT mkrt, MK_BUFN const buf, MK_STRN const varname, MK_OBJN fmtobj, MK_STRN const callfunc)
 log the whole MkBufferC object to the MkLogFileC (default: stderr) …
 
void libmkkernel::MkBufferLogS_RT (MK_RT mkrt, MK_BUFN const buf, MK_STRN const varname, MK_OBJN fmtobj, MK_STRN const callfunc)
 log the short MkBufferC object data to the MkLogFileC (default: stderr) …
 
MK_I32 libmkkernel::MkBufferCmp_RT (MK_RT mkrt, MK_BUFN const buf1, MK_BUFN const buf2)
 compare TWO MkBufferC objects like strcmp do it for strings …
 
enum MkErrorE libmkkernel::MkBufferCastTo_RT (MK_RT mkrt, MK_BUF const buf, enum MkTypeE const typ)
 change the type of an MkBufferC to type
 
MK_STRN libmkkernel::MkBufferToString_RT (MK_RT mkrt, MK_BUFN const inst)
 String-Slot - returns the string representation of the inst
 
MK_BUF libmkkernel::MkBufferSizeNew_RT (MK_RT mkrt, MK_BUF const buf, MK_NUM const size)
 alloc min size storage to the buf
 
MK_BUF libmkkernel::MkBufferSizeAdd_RT (MK_RT mkrt, MK_BUF const buf, MK_NUM const size)
 add size storage to the buf
 
MK_BUF libmkkernel::MkBufferReset_RT (MK_RT mkrt, MK_BUF const buf)
 reset a MkBufferC to the length zero …
 
void libmkkernel::MkBufferResetFull_RT (MK_RT mkrt, MK_BUF const buf)
 reset a MkBufferC to the length zero and free allocated storage…
 
MK_BUF libmkkernel::MkBufferCopy_RT (MK_RT mkrt, MK_BUF const buf, MK_BUFN const srce)
 copy the MkBufferC from srce to dest
 
MK_BUF libmkkernel::MkBufferTemp_RT (MK_RT mkrt, MK_BUFN const buf)
 create a temporary copy of the MkBufferC buf …
 
MK_BUF libmkkernel::MkBufferAppendC_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
 append a single string to a MkBufferC object …
 
MK_BUF libmkkernel::MkBufferAppendStringR_RT (MK_RT mkrt, MK_BUF const buf, MkStringR const val)
 append a single string to a MkBufferC object …
 
MK_I32 libmkkernel::MkBufferAppendVL_RT (MK_RT mkrt, MK_BUF const buf, MK_FST const printfmt, va_list var_list)
 append a single string with format and var_list arguments to a MkBuffer64S
 
MK_I32 libmkkernel::MkBufferAppendV_RT (MK_RT mkrt, MK_BUF const buf, MK_FST const printfmt,...)
 append a single string with format and ... arguments to a MkBuffer64S
 
MK_NUM libmkkernel::MkBufferPush_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
 add str to the MkBufferC
 
MK_NUM libmkkernel::MkBufferPop_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
 delete str from the MkBufferC
 
enum MkErrorE libmkkernel::MkBufferToObject_RT (MK_RT mkrt, MK_BUF const buf, MK_NAT_OBJECT *obj_out)
 return the native language object from a MkBufferC
 
MK_BUS libmkkernel::MkBufferStreamCreate_RT (MK_RT mkrt, MK_TYP type, MK_NUM const size)
 create and initialize an MkBufferStreamC instance …
 
MK_BUS libmkkernel::MkBufferStreamCreate64_RT (MK_RT mkrt, MK_NUM const size)
 call the BufferStreamCreate with default type MkBufferStream64S (64 byte) …
 
MK_BUS libmkkernel::MkBufferStreamCreate256_RT (MK_RT mkrt, MK_NUM const size)
 call the BufferStreamCreate with default type MkBufferStream256S (256 byte) …
 
MK_BUS libmkkernel::MkBufferStreamCreate1024_RT (MK_RT mkrt, MK_NUM const size)
 call the BufferStreamCreate with default type MkBufferStream1024S (1024 byte) …
 
MK_BUS libmkkernel::MkBufferStreamCreate16384_RT (MK_RT mkrt, MK_NUM const size)
 call the BufferStreamCreate with default type MkBufferStream16384S (16384 byte) …
 
MK_BUS libmkkernel::MkBufferStreamCreateTLS_RT (MK_RT mkrt, MK_STRN const tlsName, bool const resetB)
 same as BufferStreamCreate but require no cleanup …
 
void libmkkernel::MkBufferStreamCreateLOCAL_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size)
 
void libmkkernel::MkBufferStreamCreateSTATIC_T (MK_MACRO_TYP cls, MK_MACRO_TYP name)
 
void libmkkernel::MkBufferStreamCreateTLS_T (MK_MACRO_TYP cls, MK_MACRO_TYP name)
 
void libmkkernel::MkBufferStreamFree_RT (MK_RT mkrt, MK_BUS const bus)
 init and free a MkBufferStreamS reference
 
void libmkkernel::MkBufferStreamInit_RT (MK_RT mkrt, MK_BUS const bus, MK_TYP type, MK_NUM const size)
 init and free a MkBufferStreamS reference
 
void libmkkernel::MkBufferStreamDelete_RT (MK_RT mkrt, MK_BUS const bus)
 Destructor - delete a MkBufferStreamC instance …
 
MK_BUS libmkkernel::MkBufferStreamMerge_RT (MK_RT mkrt, MK_BUS const bus)
 Merge-Constructor - create a new MkBufferStreamC as a merge from an existing object …
 
MK_BUS libmkkernel::MkBufferStreamDup_RT (MK_RT mkrt, MK_BUSN const src)
 Dup-Constructor - create a new MkBufferStreamC instance as copy from an existing MkBufferStreamC instance …
 
MK_BUS libmkkernel::MkBufferStreamCopy_RT (MK_RT mkrt, MK_BUS const bus, MK_BUSN const src)
 copy the MkBufferStreamC from src to bus
 
MK_BUS libmkkernel::MkBufferStreamReset_RT (MK_RT mkrt, MK_BUS const bus)
 reset a MkBufferStreamC to the length zero …
 
void libmkkernel::MkBufferStreamResetFull_RT (MK_RT mkrt, MK_BUS const bus)
 reset a MkBufferStreamC to the length zero and free allocated storage…
 
void libmkkernel::MkBufferStreamLogS_RT (MK_RT mkrt, MK_BUS const bus, MK_OBJ fmtobj, MK_STRN const callfunc)
 
void libmkkernel::MkBufferStreamLog_RT (MK_RT mkrt, MK_BUS const bus, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the MkBufferStreamC
 
void libmkkernel::MkBufferStreamPosToStart_RT (MK_RT mkrt, MK_BUS const bus)
 set the current-access-position to the start of MkBufferStreamC
 
MK_STRN libmkkernel::MkBufferStreamToString_RT (MK_RT mkrt, MK_BUSN const inst)
 String-Slot - returns the string representation of the inst
 
MK_BFL libmkkernel::MkBufferStreamToBFL_RT (MK_RT mkrt, MK_BUSN const bus)
 convert the bus into a MkBufferListC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteI8_RT (MK_RT mkrt, MK_BUS const bus, MK_I8 const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteBOL_RT (MK_RT mkrt, MK_BUS const bus, MK_BOL const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteI32_RT (MK_RT mkrt, MK_BUS const bus, MK_I32 const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteFLT_RT (MK_RT mkrt, MK_BUS const bus, MK_FLT const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteI64_RT (MK_RT mkrt, MK_BUS const bus, MK_I64 const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteDBL_RT (MK_RT mkrt, MK_BUS const bus, MK_DBL const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteSTR_RT (MK_RT mkrt, MK_BUS const bus, MK_STRN const val, MK_NUM const len)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteBIN_RT (MK_RT mkrt, MK_BUS const bus, MkBinaryR const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteBUF_RT (MK_RT mkrt, MK_BUS const bus, MK_BUFN const val)
 write a PRIMITIVE TYPE into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteHDL_RT (MK_RT mkrt, MK_BUS const bus, MK_I32 const val)
 write the handle into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteLONG_RT (MK_RT mkrt, MK_BUS const bus, MK_LONG const val)
 write the long native object into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteVL_RT (MK_RT mkrt, MK_BUS const bus, MK_STRN const fmt, va_list ap)
 write format-string into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteV_RT (MK_RT mkrt, MK_BUS const bus, MK_STRN const fmt,...)
 write format-string into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteBFL_RT (MK_RT mkrt, MK_BUS const bus, MK_BFLN const bfl)
 write a MkBufferListC into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteL_FLAT_RT (MK_RT mkrt, MK_BUS const bus, MK_BFL const bfl)
 write a MkBufferListC FLAT into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteL_START_RT (MK_RT mkrt, MK_BUS const bus)
 START write a list-item-type into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteL_END_RT (MK_RT mkrt, MK_BUS const bus)
 END write a list-item-type into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamWriteBUS_FLAT_RT (MK_RT mkrt, MK_BUS const bus, MK_BUSN const add)
 write a MkBufferStreamC into the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadL_START_RT (MK_RT mkrt, MK_BUS const bus, MK_BUF buf)
 START read a list-item-type from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadL_END_RT (MK_RT mkrt, MK_BUS const bus)
 END read a list-item-type from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadALL_RT (MK_RT mkrt, MK_BUS const bus, MK_BFL *const val_inout)
 get a temporary MkBufferListC from all data in the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadBFL_RT (MK_RT mkrt, MK_BUS const bus, MK_BFL *const val_out)
 read a MkBufferListC from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadLIST_RT (MK_RT mkrt, MK_BUS const bus, MK_NAT_LIST *const val_out)
 
enum MkErrorE libmkkernel::MkBufferStreamReadNEXT_RT (MK_RT mkrt, MK_BUS const bus, MK_NAT_OBJECT *const val_out)
 
enum MkErrorE libmkkernel::MkBufferStreamReadLONG_RT (MK_RT mkrt, MK_BUS const bus, MK_LONG *const val_out)
 read the long native object from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadI8_RT (MK_RT mkrt, MK_BUS const bus, MK_I8 *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadBOL_RT (MK_RT mkrt, MK_BUS const bus, MK_BOL *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadI32_RT (MK_RT mkrt, MK_BUS const bus, MK_I32 *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadFLT_RT (MK_RT mkrt, MK_BUS const bus, MK_FLT *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadI64_RT (MK_RT mkrt, MK_BUS const bus, MK_I64 *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadDBL_RT (MK_RT mkrt, MK_BUS const bus, MK_DBL *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadSTR_RT (MK_RT mkrt, MK_BUS const bus, MK_STRN *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadBIN_RT (MK_RT mkrt, MK_BUS const bus, MkBinaryR *const val_out)
 read a val_out from the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadBUF_RT (MK_RT mkrt, MK_BUS const bus, MK_BUF *const val_out)
 read a val_out from the MkBufferStreamC
 
bool libmkkernel::MkBufferStreamReadItemExists_RT (MK_RT mkrt, MK_BUSN const bus)
 check if an item exists in the read-data-package
 
enum MkTypeE libmkkernel::MkBufferStreamReadGetNextType_RT (MK_RT mkrt, MK_BUSN const bus)
 get the type (MkTypeE) of the next Item in the MkBufferStreamC or "0" if not available
 
MK_NUM libmkkernel::MkBufferStreamReadGetNumItems_RT (MK_RT mkrt, MK_BUSN const bus)
 get the number of items left in the MkBufferStreamC
 
enum MkErrorE libmkkernel::MkBufferStreamReadUndo_RT (MK_RT mkrt, MK_BUS const bus)
 undo the last MkBufferStreamC READ function call …
 
enum MkErrorE libmkkernel::MkLogFileOpen_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const file, MK_LFL *lfh_out)
 open the log-file in append mode …
 
void libmkkernel::MkLogFileClose_RT (MK_RT mkrt, MK_LFL lfh)
 Destructor - delete a MkLogFileC instance …
 
enum MkErrorE libmkkernel::MkLogFileWriteVL_RT (MK_RT mkrt, MK_LFLN lfl, MK_FST printfmt, va_list var_list)
 write to log-file
 
enum MkErrorE libmkkernel::MkLogFileWriteV_RT (MK_RT mkrt, MK_LFLN lfl, MK_FST printfmt,...)
 write to log-file
 
enum MkErrorE libmkkernel::MkLogFileWriteC_RT (MK_RT mkrt, MK_LFLN lfl, MK_STRN text)
 write to log-file
 
enum MkErrorE libmkkernel::MkLogFileGetFile_RT (MK_RT mkrt, MK_LFLN lfl, MK_STRN *file_out)
 get the log-file
 
bool libmkkernel::MkExtensionDeleteAll_RT (MK_RT mkrt, MK_EXT head)
 
MK_EXT libmkkernel::MkExtensionAdd_RT (MK_RT mkrt, MK_EXT head, MK_EXT add)
 this is an update to head, use: head = MkExtensionAdd(head, add)
 
MK_EXT libmkkernel::MkExtensionDel_RT (MK_RT mkrt, MK_EXT head, MK_EXT del)
 this is an update to head, use: head = MkExtensionDel(head, del)
 
void libmkkernel::MkErrorDelete_RT (MK_RT mkrt, MK_ERR err)
 Destructor - delete a MkErrorS object …
 
MK_ERR libmkkernel::MkErrorDup_RT (MK_RT mkrt, MK_ERRN const srce)
 Dup-Constructor - create a new MkErrorC instance as copy from an existing MkErrorC instance …
 
void libmkkernel::MkErrorCopy_RT (MK_RT mkrt, MK_ERR dest, MK_ERRN const srce)
 Copy-Constructor - sync an existing MkErrorC instance with the values from an existing MkErrorC instance …
 
enum MkErrorE libmkkernel::MkErrorGetCode (MK_ERRN const err)
 get the value of MkErrorS::code
 
MK_STRN libmkkernel::MkErrorGetText (MK_ERRN const err)
 get the MkErrorS::text
 
MK_SIZE libmkkernel::MkErrorGetSize (MK_ERRN const err)
 get the error-message-size from the exception-object
 
MK_I32 libmkkernel::MkErrorGetNum (MK_ERRN const err)
 get the MkErrorS::num. The number can be used as exit-code …
 
void libmkkernel::MkErrorSetCONTINUE_RT (MK_RT mkrt, MK_ERR const err)
 signal end of processing in an MqMqEventIF callback …
 
enum MkErrorE libmkkernel::MkErrorSetEXIT_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const callfunc)
 finish the current callback, return to toplevel and MqExit the application …
 
enum MkErrorE libmkkernel::MkErrorSetSOCKET_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const detail, MK_STRN const callfunc)
 create SOCKET-DOWN error …
 
enum MkErrorE libmkkernel::MkErrorSetABORT_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const detail, MK_STRN const callfunc)
 send the ABORT signal to the calling stack…
 
void libmkkernel::MkErrorSetCode_RT (MK_RT mkrt, MK_ERR const err, enum MkErrorE code)
 set the MkErrorS::code value …
 
bool libmkkernel::MkErrorIsSOCKET (MK_ERRN const err)
 check on SOCKET-DOWN error …
 
bool libmkkernel::MkErrorIsABORT (MK_ERRN const err)
 check on ABORT signal …
 
bool libmkkernel::MkErrorIsTIMEOUT (MK_ERRN const err)
 check on TIMEOUT error …
 
bool libmkkernel::MkErrorIsEXIT (MK_ERR const err)
 check on APPLICATION-EXIT error …
 
void libmkkernel::MkPanicVL_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc, MK_I32 const errnum, MK_FST const printfmt, va_list var_list)
 do a panic with a vararg-list as argument …
 
void libmkkernel::MkPanicV_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc, MK_I32 const errnum, MK_FST const printfmt,...)
 do a panic with a vararg as argument …
 
void libmkkernel::MkPanicC_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc, MK_I32 const errnum, MK_STRN const message)
 do a panic with string as argument …
 
void libmkkernel::MkPanicDEFAULT_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_STRN const callfunc) MK_NO_RETURN
 make panic from libmkkernel::MkErrorDEFAULT_RT
 
void libmkkernel::MkDisasterSignal (MK_I32 signal)
 called if something get REALLY wrong …
 
void libmkkernel::MkErrorAppendVL_RT (MK_RT mkrt, MK_ERR const err, MK_FST const printfmt, va_list var_list)
 append a va_list string to the MkErrorC
 
void libmkkernel::MkErrorAppendV_RT (MK_RT mkrt, MK_ERR const err, MK_FST const printfmt,...)
 append a vararg string to the MkErrorC
 
void libmkkernel::MkErrorAppendC_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const message)
 append the message to the MkErrorS::text
 
MK_ERR libmkkernel::MkErrorNoRaise_RT (MK_RT mkrt, MK_ERR const err)
 ignore the next return of libmkkernel::MK_ERROR and do not raise an target-language-exception
 
enum MkErrorE libmkkernel::MkErrorSetR_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const message, enum MkErrorE const errcode, MK_I32 const errnum, MK_MNG const errctx)
 set the MkErrorC and raise the error …
 
enum MkErrorE libmkkernel::MkErrorSetE_RT (MK_RT mkrt, MK_ERR const err, MK_ERR const newerr)
 set the MkErrorC from a MkErrorC copy and raise an error …
 
enum MkErrorE libmkkernel::MkErrorSetC_RT (MK_RT mkrt, MK_ERR err, MK_STRN const message, MK_STRN const callfunc, MK_I32 const errnum)
 'set' and 'raise' the MkErrorC using a string-message and a errnum-number
 
enum MkErrorE libmkkernel::MkErrorSetVL_RT (MK_RT mkrt, MK_ERR err, MK_STRN const callfunc, MK_I32 const errnum, MK_FST const printfmt, va_list var_list)
 'set' and 'raise' the MkErrorC using a vararg-list message …
 
enum MkErrorE libmkkernel::MkErrorSetV_RT (MK_RT mkrt, MK_ERR err, MK_STRN const callfunc, MK_I32 const errnum, MK_FST const printfmt,...)
 set the MkErrorS object using a format string argument list and raise an error …
 
void libmkkernel::MkErrorCleanup_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const callfunc, MK_I32 const callline)
 cleanup and print unwanted active error …
 
void libmkkernel::MkErrorPrintln_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const msg, MK_STRN const callfunc, MK_I32 const callline)
 print the default-error to the MkLogFileC (default: stderr) and clear the error afterwards …
 
void libmkkernel::MkErrorLog_RT (MK_RT mkrt, MK_ERRN const err, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the error to MkLogFileC (default: stderr) …
 
MK_ERR libmkkernel::MkErrorCatch_RT (MK_RT mkrt, MK_ERR const err, MK_EXP const exception, MK_STRN const callfunc)
 convert a programming-language-error into an ccmkkernel error …
 
MK_ERR libmkkernel::MkObjectErrorCatch_RT (MK_RT mkrt, MK_OBJN const obj, MK_EXP const exception, MK_STRN const callfunc)
 convert a programming-language-error into an ccmkkernel error …
 
enum MkErrorE libmkkernel::MkErrorRaise_RT (MK_RT mkrt, MK_ERRN const err)
 convert an ccmkkernel error into an programming-language-error and raise afterwards. …
 
enum MkErrorE libmkkernel::MkErrorReset_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const callfunc, MK_I32 const callline, bool const force)
 This function clears the err and resets to libmkkernel::MK_OK
 
void libmkkernel::MkErrorStackFormat_RT (MK_RT mkrt, MK_ERR const err, MK_STRN callfunc, MK_STRN callfile, MK_I32 const callline)
 append an ensemble of func, file and line to the error-message
 
enum MkErrorE libmkkernel::MkErrorStack_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const callfunc, MK_STRN const callfile, MK_I32 const callline)
 check on error and if yes append an ErrorStackFormat to the error-message
 
MK_STRN libmkkernel::MkErrorToString_RT (MK_RT mkrt, MK_ERRN const inst)
 String-Slot - returns the string representation of the inst
 
bool libmkkernel::MkExceptionCheck (MK_EXP exception)
 Checks if Exception is of type MkExceptionC and returns true or false
 
void libmkkernel::MkExceptionRaise (MK_MNG const expobj, MK_STRN const callfunc, MK_I32 const callline)
 convert an MkErrorC into a Target-Programming-Language (TPL) exception …
 
MK_ERR libmkkernel::MkExceptionCatch (MK_MNG const expobj, MK_EXP const exception, MK_STRN const callfunc)
 convert an Target-Programming-Language (TPL) exception into an MkErrorC
 
MK_RT libmkkernel::MkRuntimeSetup (MK_RT const mkrt)
 initialize MkRuntimeRLS
 
void libmkkernel::MkRuntimeCleanup (MK_RT mkrt)
 cleanup MkRuntimeRLS
 
static MK_RT libmkkernel::MkRuntimeGet (void)
 return a initialized MkRuntimeRLS
 
static MK_RT libmkkernel::MkRuntimeGetFromObj (MK_OBJ obj)
 return the initialized MkRuntimeRLS from an obj
 
static bool libmkkernel::MkRuntimeIsSilentGet (void)
 get the MkRuntimeS::isSilent value …
 
static void libmkkernel::MkRuntimeIsSilentSet_RT (MK_RT mkrt, bool silent)
 set the MkRuntimeS::isSilent value …
 
static void libmkkernel::MkRuntimeNoDecoSet_RT (MK_RT mkrt, bool noDeco)
 set the MkRuntimeS::noDeco value …
 
static MK_I32 libmkkernel::MkRuntimeDebugGet (void)
 get the MkRuntimeS::debug value …
 
static void libmkkernel::MkRuntimeDebugSet (MK_I32 dbg)
 set the MkRuntimeS::debug value …
 
static MK_STRN libmkkernel::MkRuntimeLogTargetGet (void)
 get the MkLogDataS::logNAME value …
 
enum MkErrorE libmkkernel::MkRuntimeLogTargetSet_RT (MK_RT mkrt, MK_STRN logTgt)
 set the MkRuntimeS::log value and cleanup old value …
 
enum MkErrorE libmkkernel::MkRuntimeLogTargetReset_RT (MK_RT mkrt)
 set the MkRuntimeS::log value to the DEFAULT value …
 
MkLogDataS libmkkernel::MkRuntimeLogTargetPush_RT (MK_RT mkrt, MK_STRN logTgt)
 
void libmkkernel::MkRuntimeLogTargetPop_RT (MK_RT mkrt, MkLogDataS logOld)
 
void libmkkernel::MkRuntimeSetCID (MK_OBJ const cid)
 CID == context-in-duty.
 
static enum MkErrorE libmkkernel::MkRuntimeErrorGetCode_RT (MK_RT mkrt)
 return libmkkernel::MkErrorS::code from a given MkRuntimeC
 
void libmkkernel::MkRuntimeLog0_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
 log the MkRuntimeC
 
static MK_OBJ libmkkernel::MkObjectInstancesOfType_RT (MK_RT mkrt, MK_SIG typeSIG)
 return the head-instance from a specific type defined by signature typeSIG
 
static MK_ERR libmkkernel::MkObjectToError_RT (MK_RT mkrt, MK_OBJ const obj)
 Error-Slot - return an error-object pre initialized with obj data.
 
MkObjectC - Misc - function - unspecified functions to perform different tasks
static MK_OBJ libmkkernel::MkObjectGetNull (void)
 Null-Slot - return a MkObjectC typed NULL instance …
 
MkBufferC - Misc - function - unspecified functions to perform different tasks
static MK_BUF libmkkernel::MkBufferGetNull (void)
 Null-Slot - return a MkBufferC typed NULL instance …
 
MkBufferStreamC - Misc - function - unspecified functions to perform different tasks
static MK_BUS libmkkernel::MkBufferStreamGetNull (void)
 Null-Slot - return a MkBufferStreamC typed NULL instance …
 
MkLogFileC - Misc - function - unspecified functions to perform different tasks
static MK_LFL libmkkernel::MkLogFileGetNull (void)
 Null-Slot - return a MkLogFileC typed NULL instance …
 
MkErrorC - signature check
static bool libmkkernel::MkErrCheck (MK_MNGN mng)
 check MkErrorS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkErrCheckO (MK_OBJN obj)
 check MkErrorS -> libmkkernel::MkObjectS::signature
 
MkErrorC - Misc - function - unspecified functions to perform different tasks
static MK_ERR libmkkernel::MkErrorGetNull (void)
 Null-Slot - return a MkErrorC typed NULL instance …
 
MkRuntimeC - Misc - function - unspecified functions to perform different tasks
static MK_RT libmkkernel::MkRuntimeGetNull (void)
 Null-Slot - return a MkRuntimeC typed NULL instance …
 
MkBufferListC - Introspection - inline - access to all instances created by class starting with the last one
static MK_BFL libmkkernel::MkBufferListInstances_RT (MK_RT mkrt)
 get head-instance from linked-list of MkBufferListS type …
 
static MK_BFL libmkkernel::MkBufferListNext (MK_BFL const bfl)
 get next instance from linked-list of MkBufferListS type
 
static MK_BFL libmkkernel::MkBufferListPrev (MK_BFL const bfl)
 get previous instance from linked-list of MkBufferListS type
 
MkBufferC - Introspection - inline - access to all instances created by class starting with the last one
static MK_BUF libmkkernel::MkBufferInstances_RT (MK_RT mkrt)
 get head-instance from linked-list of MkBufferS type …
 
static MK_BUF libmkkernel::MkBufferNext (MK_BUF const buf)
 get next instance from linked-list of MkBufferS type
 
static MK_BUF libmkkernel::MkBufferPrev (MK_BUF const buf)
 get previous instance from linked-list of MkBufferS type
 
MkBufferStreamC - Introspection - inline - access to all instances created by class starting with the last one
static MK_BUS libmkkernel::MkBufferStreamInstances_RT (MK_RT mkrt)
 get head-instance from linked-list of MkBufferStreamS type …
 
static MK_BUS libmkkernel::MkBufferStreamNext (MK_BUS const bus)
 get next instance from linked-list of MkBufferStreamS type
 
static MK_BUS libmkkernel::MkBufferStreamPrev (MK_BUS const bus)
 get previous instance from linked-list of MkBufferStreamS type
 
MkErrorC - Introspection - inline - access to all instances created by class starting with the last one
static MK_ERR libmkkernel::MkErrorInstances_RT (MK_RT mkrt)
 get head-instance from linked-list of MkErrorS type …
 
static MK_ERR libmkkernel::MkErrorNext (MK_ERR const err)
 get next instance from linked-list of MkErrorS type
 
static MK_ERR libmkkernel::MkErrorPrev (MK_ERR const err)
 get previous instance from linked-list of MkErrorS type
 
MkLogFileC - Introspection - inline - access to all instances created by class starting with the last one
static MK_LFL libmkkernel::MkLogFileInstances_RT (MK_RT mkrt)
 get head-instance from linked-list of MkLogFileS type …
 
static MK_LFL libmkkernel::MkLogFileNext (MK_LFL const lfl)
 get next instance from linked-list of MkLogFileS type
 
static MK_LFL libmkkernel::MkLogFilePrev (MK_LFL const lfl)
 get previous instance from linked-list of MkLogFileS type
 
MkObjectC - Introspection - inline - access to all instances created by class starting with the last one
static MK_OBJ libmkkernel::MkObjectInstances_RT (MK_RT mkrt)
 get head-instance from linked-list of MkObjectS type …
 
static MK_OBJ libmkkernel::MkObjectNext (MK_OBJ const obj)
 get next instance from linked-list of MkObjectS type
 
static MK_OBJ libmkkernel::MkObjectPrev (MK_OBJ const obj)
 get previous instance from linked-list of MkObjectS type
 
MkRuntimeC - Introspection - inline - access to all instances created by class starting with the last one
static MK_RT libmkkernel::MkRuntimeInstances_RT (MK_RT mkrt)
 get head-instance from linked-list of MkRuntimeS type …
 
static MK_RT libmkkernel::MkRuntimeNext (MK_RT const rt)
 get next instance from linked-list of MkRuntimeS type
 
static MK_RT libmkkernel::MkRuntimePrev (MK_RT const rt)
 get previous instance from linked-list of MkRuntimeS type
 

Variables

bool libmkkernel::MkCleanupActive
 signal that code was triggert by MkCleanup
 
struct MkLalS libmkkernel::MkLal
 Language Abstraction Layer in duty.
 
bool libmkkernel::MkRuntimeSysPipeHandlerUse
 block SIGPIPE ignore handlern default=true, Java require this
 
__thread struct MkRuntimeS libmkkernel::MkRuntimeRLS
 RLS …
 

MK_NULL

work with the NULL value

define the NULL

This problem looks simpler than it is because NULL is not defined in every language.

TCL e.g. does not understand the NULL as a data type and an approximation with "" is only correct to the extent that the target API also understands the "" as a NULL-Value.

Unfortunately, this is not always the case and therefore:

  • wherever a NULL is explicitly required the MK_NULL is used in C++ .
  • wherever a NULL as string (libmkkernel::MK_STRN) is required then the string "MK_NULL" is used in C++.

To support the NULL the following items are defined:

  1. the NULL-value called MK_NULL
  2. the NULL-string called MK_NULL_STR
  3. the NULL-string-length called MK_NULL_STR_LEN
  4. the NULL-check called libmkkernel::MK_NULL_STR_CHECK
Note
The Programming-Language-Micro-Kernel (PLMK) translate the string "MK_NULL" into the MK_NULL pointer wherever a pointer is expected as a return value.

class-instance as NULL

MOT-Null


#define MK_NULL   NULL
 The Programming-Language-Micro-Kernel (PLMK) NULL value as MK_NULL in C++ …
 
#define MK_NULL_YES   true
 flag, allow NULL
 
#define MK_NULL_NO   false
 flag, not allow NULL
 
#define MK_NULL_STR   "MK_NULL"
 the string "MK_NULL" value as MK_NULL_STR
 
#define MK_NULL_STR_LEN   strlen(MK_NULL_STR)
 the integer strlen("MK_NULL") value as MK_NULL_STR_LEN
 
static bool libmkkernel::MK_NULL_STR_CHECK (char const *const __str, const long int __len)
 check if __str is MK_NULL_STR return true or false
 
static bool libmkkernel::MK_NULL_STR_CHECK_1 (char const *const __str)
 same as libmkkernel::MK_NULL_STR_CHECK but without len parameter
 
static bool libmkkernel::MK_NULL_STR_OR_EMPTY_CHECK_1 (char const *const __str)
 same as libmkkernel::MK_NULL_STR_CHECK together with "" check but without len parameter
 

boolean data-type

#define bool2str(_bool)
 
typedef unsigned char libmkkernel::MK_BOL
 1 byte boolean data-type
 
typedef bool libmkkernel::MK_BOOL
 real bool data-type
 

"handle" data-type

4 byte int handle data-type

The handle is a special type to represent an object as numeric-type able to be stored into an external-software.

The handle support the following API:

#define MK_HDL_REF_S3(__prefix)
 
#define MK_HDL_REF_S1(__prefix)
 
#define MK_HDLT   MK_I32T
 
typedef int32_t libmkkernel::MK_HDL
 4 byte int handle data-type
 

misc data-type

#define MK_FORMAT_N   "%i"
 
typedef long libmkkernel::MK_SIZE
 
typedef union MkBufferAtomU libmkkernel::MK_ATO
 8 byte atom data-type
 
typedef int32_t libmkkernel::MK_NUM
 array size data-type ('num' items in array …
 
typedef int libmkkernel::MK_DBG
 debug-level data-type …
 
typedef unsigned int libmkkernel::MK_SIG
 signature datatype
 

OS wide MK_TIME_T

timeout in seconds as "integer" value

#define MK_FORMAT_TIME   "%li"
 
#define MK_TIME   ((MK_TIME_T)time(NULL))
 
#define MK_TIME_MAX   (365*24*60*60)
 one year
 
typedef time_t libmkkernel::MK_TIME_T
 

MkTypeE

#define MK_TYPE_IS_1_I8E   (1<<0)
 the type is native and has a size of 1 byte …
 
#define MK_TYPE_IS_2_I8E   (1<<1)
 the type is native and has a size of 2 bytes …
 
#define MK_TYPE_IS_4_I8E   (1<<2)
 the type is native and has a size of 4 bytes …
 
#define MK_TYPE_IS_8_I8E   (1<<3)
 the type is native and has a size of 8 bytes …
 
#define MK_TYPE_IS_NATIVE
 the type is native …
 
#define MK_TYPE_SHIFT   4
 FIXED: type is only 8bit -> 4 bit=15 for type and 4 bit for flag …
 
enum  libmkkernel::MkTypeE {
  libmkkernel::MK_I8T = ((1 << MK_TYPE_SHIFT) | MK_TYPE_IS_1_I8E ) , libmkkernel::MK_BOLT = ((2 << MK_TYPE_SHIFT) | MK_TYPE_IS_1_I8E ) , libmkkernel::MK_I16T = ((3 << MK_TYPE_SHIFT) | MK_TYPE_IS_2_I8E ) , libmkkernel::MK_I32T = ((4 << MK_TYPE_SHIFT) | MK_TYPE_IS_4_I8E ) ,
  libmkkernel::MK_FLTT = ((5 << MK_TYPE_SHIFT) | MK_TYPE_IS_4_I8E ) , libmkkernel::MK_I64T = ((6 << MK_TYPE_SHIFT) | MK_TYPE_IS_8_I8E ) , libmkkernel::MK_DBLT = ((7 << MK_TYPE_SHIFT) | MK_TYPE_IS_8_I8E ) , libmkkernel::MK_BINT = ((8 << MK_TYPE_SHIFT) ) ,
  libmkkernel::MK_STRT = ((9 << MK_TYPE_SHIFT) ) , libmkkernel::MK_LSTT = ((10 << MK_TYPE_SHIFT) )
}
 basic data-types supported by Programming-Language-Micro-Kernel (PLMK)More...
 
MK_STRN libmkkernel::MkTypeE_ToString (enum MkTypeE value)
 return the MkTypeE as string …
 
static MK_I32 libmkkernel::MkTypeE_ToInt (enum MkTypeE value)
 return the MkTypeE as integer …
 
enum MkErrorE libmkkernel::MkTypeE_FromInt (MK_I32 const value, enum MkTypeE *value_out)
 return the MkTypeE from integer …
 

MkObjectC - type definition

#define MkObjectC_T   (&MK_RT_REF._MkObjectC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkObjectC_TT   (MkTYP(MkObjectC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkObjectST   MkObjectC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkObjectSTT   (MkTYP(MkObjectST))
 instance-type as MkTypeS-class-type (cast from MkObjectST into MkTypeS) …
 
#define MkObjectC_type   MK_OBJ
 same as MkObjectS but useable in a class-macro as: class##_type
 
#define MkObjectCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkObjectCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkObjectCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkObjectC_NS   MK
 map class to namespace …
 
#define MkObjectCTT   MkObjectCTT
 class as MkTypeS-class-type for MkObjectC in the Target-Programming-Language (TPL)
 
#define MkObjectCT   ( (struct MkTypeDefS *) MkObjectCTT )
 class as MkTypeDefS-class-type for MkObjectC in the Target-Programming-Language (TPL)
 
typedef struct MkObjectS libmkkernel::MkObjectCR
 instance-struct-reference same as struct MkObjectS, useable in a class-macro as: class##R
 
typedef const struct MkObjectS libmkkernel::MkObjectCNR
 const instance-struct-reference same as const struct MkObjectS, useable in a class-macro as: class##R
 

MkObjectC - signature check

#define MkObjectC_Check(mng)
 
static bool libmkkernel::MkObjCheck (MK_MNGN mng)
 check MkObjectS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkObjCheckO (MK_OBJN obj)
 check MkObjectS -> libmkkernel::MkObjectS::signature
 

MkObjectC - cast from a defined or a undefined instance

#define MkObjRaise(_obj)
 raise an error if class-instance is not valid
 
#define MkOBJ_R(x)
 cast a known-object into an MkObjectS reference
 
#define MkOBJ(x)
 cast a known-object into an MkObjectS pointer
 
static MK_OBJ libmkkernel::MkObj (MK_MNG mng)
 cast a unknown-object into an MkObjectS pointer or NULL if not possible
 
static MK_OBJN libmkkernel::MkObjN (MK_MNGN mng)
 (const) cast a unknown-object into an MkObjectS pointer or NULL if not possible
 

MkObjectC - Export - inline - interact with an external software

#define MkObjectHandleGetOfType_1X(x)
 
#define MkObjectHandleGet_1X(x)
 
#define MkObjectHandleResolve_e(netHdl)
 wrapper for MkObjectHandleResolve with error-handline
 
static MK_HDL libmkkernel::MkObjectHandleGetOfType (MK_OBJ const obj)
 Export-Slot - returns typeHdl of the obj .
 
bool libmkkernel::MkObjectHandleExists (MK_OBJ const obj)
 check if obj has already a handle defined…
 
MK_HDL libmkkernel::MkObjectHandleGetOr0 (MK_OBJ const obj)
 return export-hdl or 0 in not created…
 
MK_HDL libmkkernel::MkObjectHandleGet_RT (MK_RT mkrt, MK_OBJ const obj)
 Handle-Get-Slot - returns a export-hdl to the MkObjectC useable for external storage
 
MK_OBJ libmkkernel::MkObjectHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
 Handle-Resolve-Slot - return a MkObjectC from netHdl or MK_NULL if invalid…
 
void libmkkernel::MkObjectHandleDeleteByNetHdl_RT (MK_RT mkrt, MK_HDL const netHdl)
 Handle-Delete-Slot - delete a netHdl from handle-storage …
 
void libmkkernel::MkObjectHandleDelete_RT (MK_RT mkrt, MK_OBJ const netObj)
 Handle-Delete-Slot - delete a netObj from handle-storage …
 

MkTypeC - type definition

#define MkTypeSTT   (&MK_RT_REF._MkTypeC_TT)
 instance-type as MkTypeS-class-type
 
#define MkTypeC_TT   (&MK_RT_REF._MkTypeC_TT)
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkTypeC_type   MK_TYP
 same as MkTypeS but useable in a class-macro as: class##_type
 
#define MkTypeCT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkTypeCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkTypeCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeS-class-type …
 
#define MkTypeC_NS   MK
 map class to namespace …
 
#define MkTypeCTT   MkTypeCTT
 class as MkTypeS-class-type for MkTypeC in the Target-Programming-Language (TPL)
 
#define MkTypeCT   ( (struct MkTypeS *) MkTypeCTT )
 class as MkTypeS-class-type for MkTypeC in the Target-Programming-Language (TPL)
 
typedef struct MkTypeS libmkkernel::MkTypeCR
 instance-struct-reference same as struct MkTypeS, useable in a class-macro as: class##R
 
typedef const struct MkTypeS libmkkernel::MkTypeCNR
 const instance-struct-reference same as const struct MkTypeS, useable in a class-macro as: class##R
 

MkTypeC - signature check

#define MkTypeC_Check(mng)
 
static bool libmkkernel::MkTypCheck (MK_MNGN mng)
 check MkTypeS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkTypCheckO (MK_OBJN obj)
 check MkTypeS -> libmkkernel::MkObjectS::signature
 

MkTypeDefC - type definition

#define MkTypeDefSTT   (&MK_RT_REF._MkTypeDefC_TT)
 instance-type as MkTypeS-class-type
 
#define MkTypeDefC_TT   (&MK_RT_REF._MkTypeDefC_TT)
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkTypeDefCT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkTypeDefCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkTypeDefCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeS-class-type …
 
#define MkTypeDefC_NS   MK
 map class to namespace …
 
#define MkTypeDefCTT   MkTypeDefCTT
 class as MkTypeS-class-type for MkTypeDefC in the Target-Programming-Language (TPL)
 
#define MkTypeDefCT   ( (struct MkTypeS *) MkTypeDefCTT )
 class as MkTypeS-class-type for MkTypeDefC in the Target-Programming-Language (TPL)
 
typedef struct MkTypeDefS libmkkernel::MkTypeDefCR
 instance-struct-reference same as struct MkTypeDefS, useable in a class-macro as: class##R
 
typedef const struct MkTypeDefS libmkkernel::MkTypeDefCNR
 const instance-struct-reference same as const struct MkTypeDefS, useable in a class-macro as: class##R
 

MkRef…

reference management functions

#define MkRefLOCK   999999
 unchangeable reference
 
#define MkRefIncr_1X(x)
 
#define MkRefIncr_1M(m)
 
#define MkRefIncr_FX(x)
 protect code-block, do not call the destructor…
 
#define MkRefDecr_O(o)
 
#define MkRefDecr_X(x)
 
#define MkRefDecr_X_NULL(x)
 same as MkRefDecr_X but do not expect a runtime-cache.
 
#define MkRefDecr_M(m)
 
#define MkRefDecr_M_NULL(m)
 same as MkRefDecr_M but do not expect a runtime-cache.
 
#define MkRefDecr_FX(x)
 protect code-block, do not call the destructor…
 
#define MkRefIncrSelf_2X(x, s)
 
#define MkRefGet_1X(x)
 
#define MkRefLock_1X(x)
 
#define MkRefIsLocked_1X(x)
 
#define MkRefSet(target, source)
 update target with source and keep the MkObjectS::refCount in sync
 
static void libmkkernel::MkRefIncr (MK_OBJ obj)
 increment the reference-count
 
void libmkkernel::MkRefDecr_RT (MK_RT mkrt, MK_OBJ obj)
 decrement the reference-count
 
static void libmkkernel::MkRefIncrSelf (MK_OBJ const obj, MK_PTR const self, MK_PTR const env)
 ATOMIC operation -> link self with reference-count.
 
MK_OBJ libmkkernel::MkRefDecrWithoutSelf_RT (MK_RT mkrt, MK_OBJ const obj)
 ATOMIC operation -> unlink self with reference-count.
 
MK_OBJ libmkkernel::MkRefDecrWithUnlinkSelf_RT (MK_RT mkrt, MK_OBJ const obj)
 ATOMIC operation -> unlink self from META und decr-ref-count in META.
 
static MK_I32 libmkkernel::MkRefGet (MK_OBJ const obj)
 get the reference-count
 
static MK_I32 libmkkernel::MkRefLock (MK_OBJ const obj)
 lock the object
 
static bool libmkkernel::MkRefIsLocked (MK_OBJ const obj)
 check if object is locked
 
MK_NUM libmkkernel::MkRefCidN_RT (MK_RT mkrt)
 return the reference-count-recursion-level
 

MkSelf

#define MkSelfSet_3X(x, self, env)
 
#define MkSelfGet_1X(x)
 
#define MkSelfNew_3X(x, self_out, env)
 
#define MkSelfCreate_2X(x, env)
 
#define MkSelfDelete_1X(x)
 
#define MkSelfDeleteForce_1X(x)
 
#define MkSelfUnlink_1X(x)
 
#define MkSelfExists_1X(x)
 
typedef void(* libmkkernel::MkSelfIncrF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)
 
typedef void(* libmkkernel::MkSelfDecrF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)
 
static void libmkkernel::MkSelfSet (MK_OBJ const obj, MK_PTR const self, MK_PTR const env)
 set the MkObjectS::self value
 
static MK_PTR libmkkernel::MkSelfGet (MK_OBJ const obj)
 get the MkObjectS::self value
 
static MK_ATTR_HOT enum MkErrorE libmkkernel::MkSelfNew_RT (MK_RT mkrt, MK_OBJ obj, MK_PTR *self_out, MK_PTR const env)
 return the self pointer for a given obj
 
MK_PTR libmkkernel::MkSelfCreate_RT (MK_RT mkrt, MK_OBJ const obj, MK_PTR const env)
 create the MkObjectS::self value
 
bool libmkkernel::MkSelfDelete_RT (MK_RT mkrt, MK_OBJ const obj)
 delete the MkObjectS::self value
 
bool libmkkernel::MkSelfDeleteForce_RT (MK_RT mkrt, MK_OBJ obj)
 force delete an instance, last step in instance-destructor
 
void libmkkernel::MkSelfUnlink_RT (MK_RT mkrt, MK_OBJ obj)
 Run the MkTypeS::selfUnlink slot from the instance...
 
static bool libmkkernel::MkSelfExists (MK_OBJN obj)
 Check if the MkObjectS::self exists …
 

MkBufferC - type definition

#define MkBufferC_T   (&MK_RT_REF._MkBufferC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBufferC_TT   (MkTYP(MkBufferC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBufferST   MkBufferC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBufferSTT   (MkTYP(MkBufferST))
 instance-type as MkTypeS-class-type (cast from MkBufferST into MkTypeS) …
 
#define MkBufferC_type   MK_BUF
 same as MkBufferS but useable in a class-macro as: class##_type
 
#define MkBufferCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBufferCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBufferCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBufferC_NS   MK
 map class to namespace …
 
#define MkBufferCTT   MkBufferCTT
 class as MkTypeS-class-type for MkBufferC in the Target-Programming-Language (TPL)
 
#define MkBufferCT   ( (struct MkTypeDefS *) MkBufferCTT )
 class as MkTypeDefS-class-type for MkBufferC in the Target-Programming-Language (TPL)
 
typedef struct MkBufferS libmkkernel::MkBufferCR
 instance-struct-reference same as struct MkBufferS, useable in a class-macro as: class##R
 
typedef const struct MkBufferS libmkkernel::MkBufferCNR
 const instance-struct-reference same as const struct MkBufferS, useable in a class-macro as: class##R
 

MkBufferC - signature check

#define MkBufferC_Check(mng)
 
static bool libmkkernel::MkBufCheck (MK_MNGN mng)
 check MkBufferS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkBufCheckO (MK_OBJN obj)
 check MkBufferS -> libmkkernel::MkObjectS::signature
 

MkBufferC - cast from a defined or a undefined instance

#define MkBufRaise(_buf)
 raise an error if class-instance is not valid
 
#define MkBUF_R(x)
 cast a known-object into an MkBufferS reference
 
#define MkBUF(x)
 cast a known-object into an MkBufferS pointer
 
static MK_BUF libmkkernel::MkBuf (MK_MNG mng)
 cast a unknown-object into an MkBufferS pointer or NULL if not possible
 
static MK_BUFN libmkkernel::MkBufN (MK_MNGN mng)
 (const) cast a unknown-object into an MkBufferS pointer or NULL if not possible
 

MkBufferC - Export - inline - interact with an external software

#define MkBufferHandleResolve_e(netHdl)
 wrapper for MkBufferHandleResolve with error-handline
 
static MK_HDL libmkkernel::MkBufferHandleGet_RT (MK_RT mkrt, MK_BUF const buf)
 Handle-Get-Slot - returns a export-hdl to the MkBufferC useable for external storage
 
static MK_BUF libmkkernel::MkBufferHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
 Handle-Resolve-Slot - return a MkBufferC from netHdl or MK_NULL if invalid…
 

MkBuffer64C - type definition

#define MkBuffer64C_T   (&MK_RT_REF._MkBuffer64C_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBuffer64C_TT   (MkTYP(MkBuffer64C_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBuffer64ST   MkBuffer64C_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBuffer64STT   (MkTYP(MkBuffer64ST))
 instance-type as MkTypeS-class-type (cast from MkBuffer64ST into MkTypeS) …
 
#define MkBuffer64CT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBuffer64CTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBuffer64CT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBuffer64C_NS   MK
 map class to namespace …
 
#define MkBuffer64CTT   MkBuffer64CTT
 class as MkTypeS-class-type for MkBuffer64C in the Target-Programming-Language (TPL)
 
#define MkBuffer64CT   ( (struct MkTypeDefS *) MkBuffer64CTT )
 class as MkTypeDefS-class-type for MkBuffer64C in the Target-Programming-Language (TPL)
 
typedef struct MkBuffer64S libmkkernel::MkBuffer64CR
 instance-struct-reference same as struct MkBuffer64S, useable in a class-macro as: class##R
 
typedef const struct MkBuffer64S libmkkernel::MkBuffer64CNR
 const instance-struct-reference same as const struct MkBuffer64S, useable in a class-macro as: class##R
 

MkBuffer256C - type definition

#define MkBuffer256C_T   (&MK_RT_REF._MkBuffer256C_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBuffer256C_TT   (MkTYP(MkBuffer256C_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBuffer256ST   MkBuffer256C_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBuffer256STT   (MkTYP(MkBuffer256ST))
 instance-type as MkTypeS-class-type (cast from MkBuffer256ST into MkTypeS) …
 
#define MkBuffer256CT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBuffer256CTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBuffer256CT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBuffer256C_NS   MK
 map class to namespace …
 
#define MkBuffer256CTT   MkBuffer256CTT
 class as MkTypeS-class-type for MkBuffer256C in the Target-Programming-Language (TPL)
 
#define MkBuffer256CT   ( (struct MkTypeDefS *) MkBuffer256CTT )
 class as MkTypeDefS-class-type for MkBuffer256C in the Target-Programming-Language (TPL)
 
typedef struct MkBuffer256S libmkkernel::MkBuffer256CR
 instance-struct-reference same as struct MkBuffer256S, useable in a class-macro as: class##R
 
typedef const struct MkBuffer256S libmkkernel::MkBuffer256CNR
 const instance-struct-reference same as const struct MkBuffer256S, useable in a class-macro as: class##R
 

MkBuffer1024C - type definition

#define MkBuffer1024C_T   (&MK_RT_REF._MkBuffer1024C_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBuffer1024C_TT   (MkTYP(MkBuffer1024C_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBuffer1024ST   MkBuffer1024C_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBuffer1024STT   (MkTYP(MkBuffer1024ST))
 instance-type as MkTypeS-class-type (cast from MkBuffer1024ST into MkTypeS) …
 
#define MkBuffer1024CT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBuffer1024CTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBuffer1024CT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBuffer1024C_NS   MK
 map class to namespace …
 
#define MkBuffer1024CTT   MkBuffer1024CTT
 class as MkTypeS-class-type for MkBuffer1024C in the Target-Programming-Language (TPL)
 
#define MkBuffer1024CT   ( (struct MkTypeDefS *) MkBuffer1024CTT )
 class as MkTypeDefS-class-type for MkBuffer1024C in the Target-Programming-Language (TPL)
 
typedef struct MkBuffer1024S libmkkernel::MkBuffer1024CR
 instance-struct-reference same as struct MkBuffer1024S, useable in a class-macro as: class##R
 
typedef const struct MkBuffer1024S libmkkernel::MkBuffer1024CNR
 const instance-struct-reference same as const struct MkBuffer1024S, useable in a class-macro as: class##R
 

MkString2TT

Function used to convert a string into a ccmkkernel native type …

#define MkString2O(s, l, r)
 
#define MkString2Y(s, l, r)
 
#define MkString2S(s, l, r)
 
#define MkString2US(s, l, r)
 
#define MkString2I(s, l, r)
 
#define MkString2UI(s, l, r)
 
#define MkString2W(s, l, r)
 
#define MkString2F(s, l, r)
 
#define MkString2D(s, l, r)
 
enum MkErrorE libmkkernel::MkString2BOL_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_BOL *val_out)
 convert a string into a native
 
enum MkErrorE libmkkernel::MkString2I8_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I8 *val_out)
 
enum MkErrorE libmkkernel::MkString2I16_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I16 *val_out)
 
enum MkErrorE libmkkernel::MkString2U16_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_U16 *val_out)
 
enum MkErrorE libmkkernel::MkString2I32_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I32 *val_out)
 
enum MkErrorE libmkkernel::MkString2U32_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_U32 *val_out)
 
enum MkErrorE libmkkernel::MkString2I64_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I64 *val_out)
 
enum MkErrorE libmkkernel::MkString2FLT_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_FLT *val_out)
 
enum MkErrorE libmkkernel::MkString2DBL_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_DBL *val_out)
 
enum MkErrorE libmkkernel::MkString2LONG_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_LONG *val_out)
 
enum MkErrorE libmkkernel::MkString2BOOL_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_BOOL *val_out)
 
enum MkErrorE libmkkernel::MkString2ATO_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, enum MkTypeE type, MK_ATO *val_out)
 
enum MkErrorE libmkkernel::MkString2HDL_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_HDL *val_out)
 

MkBufferStreamC - type definition

#define MkBufferStreamC_T   (&MK_RT_REF._MkBufferStreamC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBufferStreamC_TT   (MkTYP(MkBufferStreamC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBufferStreamST   MkBufferStreamC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBufferStreamSTT   (MkTYP(MkBufferStreamST))
 instance-type as MkTypeS-class-type (cast from MkBufferStreamST into MkTypeS) …
 
#define MkBufferStreamC_type   MK_BUS
 same as MkBufferStreamS but useable in a class-macro as: class##_type
 
#define MkBufferStreamCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBufferStreamCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBufferStreamCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBufferStreamC_NS   MK
 map class to namespace …
 
#define MkBufferStreamCTT   MkBufferStreamCTT
 class as MkTypeS-class-type for MkBufferStreamC in the Target-Programming-Language (TPL)
 
#define MkBufferStreamCT   ( (struct MkTypeDefS *) MkBufferStreamCTT )
 class as MkTypeDefS-class-type for MkBufferStreamC in the Target-Programming-Language (TPL)
 
typedef struct MkBufferStreamS libmkkernel::MkBufferStreamCR
 instance-struct-reference same as struct MkBufferStreamS, useable in a class-macro as: class##R
 
typedef const struct MkBufferStreamS libmkkernel::MkBufferStreamCNR
 const instance-struct-reference same as const struct MkBufferStreamS, useable in a class-macro as: class##R
 

MkBufferStreamC - signature check

#define MkBufferStreamC_Check(mng)
 
static bool libmkkernel::MkBusCheck (MK_MNGN mng)
 check MkBufferStreamS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkBusCheckO (MK_OBJN obj)
 check MkBufferStreamS -> libmkkernel::MkObjectS::signature
 

MkBufferStreamC - cast from a defined or a undefined instance

#define MkBusRaise(_bus)
 raise an error if class-instance is not valid
 
#define MkBUS_R(x)
 cast a known-object into an MkBufferStreamS reference
 
#define MkBUS(x)
 cast a known-object into an MkBufferStreamS pointer
 
static MK_BUS libmkkernel::MkBus (MK_MNG mng)
 cast a unknown-object into an MkBufferStreamS pointer or NULL if not possible
 
static MK_BUSN libmkkernel::MkBusN (MK_MNGN mng)
 (const) cast a unknown-object into an MkBufferStreamS pointer or NULL if not possible
 

MkBufferStreamC - Export - inline - interact with an external software

#define MkBufferStreamHandleResolve_e(netHdl)
 wrapper for MkBufferStreamHandleResolve with error-handline
 
static MK_HDL libmkkernel::MkBufferStreamHandleGet_RT (MK_RT mkrt, MK_BUS const bus)
 Handle-Get-Slot - returns a export-hdl to the MkBufferStreamC useable for external storage
 
static MK_BUS libmkkernel::MkBufferStreamHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
 Handle-Resolve-Slot - return a MkBufferStreamC from netHdl or MK_NULL if invalid…
 

MkBufferStream64C - type definition

#define MkBufferStream64C_T   (&MK_RT_REF._MkBufferStream64C_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBufferStream64C_TT   (MkTYP(MkBufferStream64C_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBufferStream64ST   MkBufferStream64C_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBufferStream64STT   (MkTYP(MkBufferStream64ST))
 instance-type as MkTypeS-class-type (cast from MkBufferStream64ST into MkTypeS) …
 
#define MkBufferStream64CT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBufferStream64CTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBufferStream64CT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBufferStream64C_NS   MK
 map class to namespace …
 
#define MkBufferStream64CTT   MkBufferStream64CTT
 class as MkTypeS-class-type for MkBufferStream64C in the Target-Programming-Language (TPL)
 
#define MkBufferStream64CT   ( (struct MkTypeDefS *) MkBufferStream64CTT )
 class as MkTypeDefS-class-type for MkBufferStream64C in the Target-Programming-Language (TPL)
 
typedef struct MkBufferStream64S libmkkernel::MkBufferStream64CR
 instance-struct-reference same as struct MkBufferStream64S, useable in a class-macro as: class##R
 
typedef const struct MkBufferStream64S libmkkernel::MkBufferStream64CNR
 const instance-struct-reference same as const struct MkBufferStream64S, useable in a class-macro as: class##R
 

MkBufferStream256C - type definition

#define MkBufferStream256C_T   (&MK_RT_REF._MkBufferStream256C_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBufferStream256C_TT   (MkTYP(MkBufferStream256C_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBufferStream256ST   MkBufferStream256C_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBufferStream256STT   (MkTYP(MkBufferStream256ST))
 instance-type as MkTypeS-class-type (cast from MkBufferStream256ST into MkTypeS) …
 
#define MkBufferStream256CT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBufferStream256CTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBufferStream256CT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBufferStream256C_NS   MK
 map class to namespace …
 
#define MkBufferStream256CTT   MkBufferStream256CTT
 class as MkTypeS-class-type for MkBufferStream256C in the Target-Programming-Language (TPL)
 
#define MkBufferStream256CT   ( (struct MkTypeDefS *) MkBufferStream256CTT )
 class as MkTypeDefS-class-type for MkBufferStream256C in the Target-Programming-Language (TPL)
 
typedef struct MkBufferStream256S libmkkernel::MkBufferStream256CR
 instance-struct-reference same as struct MkBufferStream256S, useable in a class-macro as: class##R
 
typedef const struct MkBufferStream256S libmkkernel::MkBufferStream256CNR
 const instance-struct-reference same as const struct MkBufferStream256S, useable in a class-macro as: class##R
 

MkBufferStream1024C - type definition

#define MkBufferStream1024C_T   (&MK_RT_REF._MkBufferStream1024C_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBufferStream1024C_TT   (MkTYP(MkBufferStream1024C_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBufferStream1024ST   MkBufferStream1024C_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBufferStream1024STT   (MkTYP(MkBufferStream1024ST))
 instance-type as MkTypeS-class-type (cast from MkBufferStream1024ST into MkTypeS) …
 
#define MkBufferStream1024CT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBufferStream1024CTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBufferStream1024CT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBufferStream1024C_NS   MK
 map class to namespace …
 
#define MkBufferStream1024CTT   MkBufferStream1024CTT
 class as MkTypeS-class-type for MkBufferStream1024C in the Target-Programming-Language (TPL)
 
#define MkBufferStream1024CT   ( (struct MkTypeDefS *) MkBufferStream1024CTT )
 class as MkTypeDefS-class-type for MkBufferStream1024C in the Target-Programming-Language (TPL)
 
typedef struct MkBufferStream1024S libmkkernel::MkBufferStream1024CR
 instance-struct-reference same as struct MkBufferStream1024S, useable in a class-macro as: class##R
 
typedef const struct MkBufferStream1024S libmkkernel::MkBufferStream1024CNR
 const instance-struct-reference same as const struct MkBufferStream1024S, useable in a class-macro as: class##R
 

MkBufferStream16384C - type definition

#define MkBufferStream16384C_T   (&MK_RT_REF._MkBufferStream16384C_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkBufferStream16384C_TT   (MkTYP(MkBufferStream16384C_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkBufferStream16384ST   MkBufferStream16384C_T
 instance-type as MkTypeDefS-class-type …
 
#define MkBufferStream16384STT   (MkTYP(MkBufferStream16384ST))
 instance-type as MkTypeS-class-type (cast from MkBufferStream16384ST into MkTypeS) …
 
#define MkBufferStream16384CT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkBufferStream16384CTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkBufferStream16384CT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkBufferStream16384C_NS   MK
 map class to namespace …
 
#define MkBufferStream16384CTT   MkBufferStream16384CTT
 class as MkTypeS-class-type for MkBufferStream16384C in the Target-Programming-Language (TPL)
 
#define MkBufferStream16384CT   ( (struct MkTypeDefS *) MkBufferStream16384CTT )
 class as MkTypeDefS-class-type for MkBufferStream16384C in the Target-Programming-Language (TPL)
 
typedef struct MkBufferStream16384S libmkkernel::MkBufferStream16384CR
 instance-struct-reference same as struct MkBufferStream16384S, useable in a class-macro as: class##R
 
typedef const struct MkBufferStream16384S libmkkernel::MkBufferStream16384CNR
 const instance-struct-reference same as const struct MkBufferStream16384S, useable in a class-macro as: class##R
 

MkLogFileC - type definition

#define MkLogFileC_T   (&MK_RT_REF._MkLogFileC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkLogFileC_TT   (MkTYP(MkLogFileC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkLogFileST   MkLogFileC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkLogFileSTT   (MkTYP(MkLogFileST))
 instance-type as MkTypeS-class-type (cast from MkLogFileST into MkTypeS) …
 
#define MkLogFileC_type   MK_LFL
 same as MkLogFileS but useable in a class-macro as: class##_type
 
#define MkLogFileCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkLogFileCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkLogFileCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkLogFileC_NS   MK
 map class to namespace …
 
#define MkLogFileCTT   MkLogFileCTT
 class as MkTypeS-class-type for MkLogFileC in the Target-Programming-Language (TPL)
 
#define MkLogFileCT   ( (struct MkTypeDefS *) MkLogFileCTT )
 class as MkTypeDefS-class-type for MkLogFileC in the Target-Programming-Language (TPL)
 
typedef struct MkLogFileS libmkkernel::MkLogFileCR
 instance-struct-reference same as struct MkLogFileS, useable in a class-macro as: class##R
 
typedef const struct MkLogFileS libmkkernel::MkLogFileCNR
 const instance-struct-reference same as const struct MkLogFileS, useable in a class-macro as: class##R
 

MkLogFileC - signature check

#define MkLogFileC_Check(mng)
 
static bool libmkkernel::MkLflCheck (MK_MNGN mng)
 check MkLogFileS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkLflCheckO (MK_OBJN obj)
 check MkLogFileS -> libmkkernel::MkObjectS::signature
 

MkLogFileC - cast from a defined or a undefined instance

#define MkLflRaise(_lfl)
 raise an error if class-instance is not valid
 
#define MkLFL_R(x)
 cast a known-object into an MkLogFileS reference
 
#define MkLFL(x)
 cast a known-object into an MkLogFileS pointer
 
static MK_LFL libmkkernel::MkLfl (MK_MNG mng)
 cast a unknown-object into an MkLogFileS pointer or NULL if not possible
 
static MK_LFLN libmkkernel::MkLflN (MK_MNGN mng)
 (const) cast a unknown-object into an MkLogFileS pointer or NULL if not possible
 

MkLogFileC - Export - inline - interact with an external software

#define MkLogFileHandleResolve_e(netHdl)
 wrapper for MkLogFileHandleResolve with error-handline
 
static MK_HDL libmkkernel::MkLogFileHandleGet_RT (MK_RT mkrt, MK_LFL const lfl)
 Handle-Get-Slot - returns a export-hdl to the MkLogFileC useable for external storage
 
static MK_LFL libmkkernel::MkLogFileHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
 Handle-Resolve-Slot - return a MkLogFileC from netHdl or MK_NULL if invalid…
 

MkExtensionC - type definition

#define MkExtensionC_T   (&MK_RT_REF._MkExtensionC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkExtensionC_TT   (MkTYP(MkExtensionC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkExtensionST   MkExtensionC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkExtensionSTT   (MkTYP(MkExtensionST))
 instance-type as MkTypeS-class-type (cast from MkExtensionST into MkTypeS) …
 
#define MkExtensionC_type   MK_EXT
 same as MkExtensionS but useable in a class-macro as: class##_type
 
#define MkExtensionCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkExtensionCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkExtensionCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkExtensionC_NS   MK
 map class to namespace …
 
#define MkExtensionCTT   MkExtensionCTT
 class as MkTypeS-class-type for MkExtensionC in the Target-Programming-Language (TPL)
 
#define MkExtensionCT   ( (struct MkTypeDefS *) MkExtensionCTT )
 class as MkTypeDefS-class-type for MkExtensionC in the Target-Programming-Language (TPL)
 
typedef struct MkExtensionS libmkkernel::MkExtensionCR
 instance-struct-reference same as struct MkExtensionS, useable in a class-macro as: class##R
 
typedef const struct MkExtensionS libmkkernel::MkExtensionCNR
 const instance-struct-reference same as const struct MkExtensionS, useable in a class-macro as: class##R
 

MkExtensionC - signature check

#define MkExtensionC_Check(mng)
 
static bool libmkkernel::MkExtCheck (MK_MNGN mng)
 check MkExtensionS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkExtCheckO (MK_OBJN obj)
 check MkExtensionS -> libmkkernel::MkObjectS::signature
 

MkExtensionC - cast from a defined or a undefined instance

#define MkExtRaise(_ext)
 raise an error if class-instance is not valid
 
#define MkEXT_R(x)
 cast a known-object into an MkExtensionS reference
 
#define MkEXT(x)
 cast a known-object into an MkExtensionS pointer
 
static MK_EXT libmkkernel::MkExt (MK_MNG mng)
 cast a unknown-object into an MkExtensionS pointer or NULL if not possible
 
static MK_EXTN libmkkernel::MkExtN (MK_MNGN mng)
 (const) cast a unknown-object into an MkExtensionS pointer or NULL if not possible
 

MkErrorC - type definition

#define MkErrorC_T   (&MK_RT_REF._MkErrorC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkErrorC_TT   (MkTYP(MkErrorC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkErrorST   MkErrorC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkErrorSTT   (MkTYP(MkErrorST))
 instance-type as MkTypeS-class-type (cast from MkErrorST into MkTypeS) …
 
#define MkErrorC_type   MK_ERR
 same as MkErrorS but useable in a class-macro as: class##_type
 
#define MkErrorCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkErrorCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkErrorCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkErrorC_NS   MK
 map class to namespace …
 
#define MkErrorCTT   MkErrorCTT
 class as MkTypeS-class-type for MkErrorC in the Target-Programming-Language (TPL)
 
#define MkErrorCT   ( (struct MkTypeDefS *) MkErrorCTT )
 class as MkTypeDefS-class-type for MkErrorC in the Target-Programming-Language (TPL)
 
typedef struct MkErrorS libmkkernel::MkErrorCR
 instance-struct-reference same as struct MkErrorS, useable in a class-macro as: class##R
 
typedef const struct MkErrorS libmkkernel::MkErrorCNR
 const instance-struct-reference same as const struct MkErrorS, useable in a class-macro as: class##R
 

MkErrorC - cast from a defined or a undefined instance

#define MkErrRaise(_err)
 raise an error if class-instance is not valid
 
#define MkERR_R(x)
 cast a known-object into an MkErrorS reference
 
#define MkERR(x)
 cast a known-object into an MkErrorS pointer
 
static MK_ERR libmkkernel::MkErr (MK_MNG mng)
 cast a unknown-object into an MkErrorS pointer or NULL if not possible
 
static MK_ERRN libmkkernel::MkErrN (MK_MNGN mng)
 (const) cast a unknown-object into an MkErrorS pointer or NULL if not possible
 

MkErrorC - Export - inline - interact with an external software

#define MkErrorHandleResolve_e(netHdl)
 wrapper for MkErrorHandleResolve with error-handline
 
static MK_HDL libmkkernel::MkErrorHandleGet_RT (MK_RT mkrt, MK_ERR const err)
 Handle-Get-Slot - returns a export-hdl to the MkErrorC useable for external storage
 
static MK_ERR libmkkernel::MkErrorHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
 Handle-Resolve-Slot - return a MkErrorC from netHdl or MK_NULL if invalid…
 

MkErrExtC - type definition

#define MkErrExtC_T   (&MK_RT_REF._MkErrExtC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkErrExtC_TT   (MkTYP(MkErrExtC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkErrExtST   MkErrExtC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkErrExtSTT   (MkTYP(MkErrExtST))
 instance-type as MkTypeS-class-type (cast from MkErrExtST into MkTypeS) …
 
#define MkErrExtC_type   MK_ERREXT
 same as MkErrExtS but useable in a class-macro as: class##_type
 
#define MkErrExtCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkErrExtCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkErrExtCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkErrExtC_NS   MK
 map class to namespace …
 
#define MkErrExtCTT   MkErrExtCTT
 class as MkTypeS-class-type for MkErrExtC in the Target-Programming-Language (TPL)
 
#define MkErrExtCT   ( (struct MkTypeDefS *) MkErrExtCTT )
 class as MkTypeDefS-class-type for MkErrExtC in the Target-Programming-Language (TPL)
 
typedef struct MkErrExtS libmkkernel::MkErrExtCR
 instance-struct-reference same as struct MkErrExtS, useable in a class-macro as: class##R
 
typedef const struct MkErrExtS libmkkernel::MkErrExtCNR
 const instance-struct-reference same as const struct MkErrExtS, useable in a class-macro as: class##R
 

MkErrExtC - signature check

#define MkErrExtC_Check(mng)
 
static bool libmkkernel::MkErrExtCheck (MK_MNGN mng)
 check MkErrExtS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkErrExtCheckO (MK_OBJN obj)
 check MkErrExtS -> libmkkernel::MkObjectS::signature
 

MkErrExtC - cast from a defined or a undefined instance

#define MkErrExtRaise(_errext)
 raise an error if class-instance is not valid
 
#define MkERREXT_R(x)
 cast a known-object into an MkErrExtS reference
 
#define MkERREXT(x)
 cast a known-object into an MkErrExtS pointer
 
static MK_ERREXT libmkkernel::MkErrExt (MK_MNG mng)
 cast a unknown-object into an MkErrExtS pointer or NULL if not possible
 
static MK_ERREXTN libmkkernel::MkErrExtN (MK_MNGN mng)
 (const) cast a unknown-object into an MkErrExtS pointer or NULL if not possible
 

MkErrorPanicC - type definition

#define MkErrorPanicC_T   (&MK_RT_REF._MkErrorPanicC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkErrorPanicC_TT   (MkTYP(MkErrorPanicC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkErrorPanicST   MkErrorPanicC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkErrorPanicSTT   (MkTYP(MkErrorPanicST))
 instance-type as MkTypeS-class-type (cast from MkErrorPanicST into MkTypeS) …
 
#define MkErrorPanicCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkErrorPanicCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkErrorPanicCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkErrorPanicC_NS   MK
 map class to namespace …
 
#define MkErrorPanicCTT   MkErrorPanicCTT
 class as MkTypeS-class-type for MkErrorPanicC in the Target-Programming-Language (TPL)
 
#define MkErrorPanicCT   ( (struct MkTypeDefS *) MkErrorPanicCTT )
 class as MkTypeDefS-class-type for MkErrorPanicC in the Target-Programming-Language (TPL)
 
typedef struct MkErrorPanicS libmkkernel::MkErrorPanicCR
 instance-struct-reference same as struct MkErrorPanicS, useable in a class-macro as: class##R
 
typedef const struct MkErrorPanicS libmkkernel::MkErrorPanicCNR
 const instance-struct-reference same as const struct MkErrorPanicS, useable in a class-macro as: class##R
 

MkErrorExitC - type definition

#define MkErrorExitC_T   (&MK_RT_REF._MkErrorExitC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkErrorExitC_TT   (MkTYP(MkErrorExitC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkErrorExitST   MkErrorExitC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkErrorExitSTT   (MkTYP(MkErrorExitST))
 instance-type as MkTypeS-class-type (cast from MkErrorExitST into MkTypeS) …
 
#define MkErrorExitCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkErrorExitCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkErrorExitCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkErrorExitC_NS   MK
 map class to namespace …
 
#define MkErrorExitCTT   MkErrorExitCTT
 class as MkTypeS-class-type for MkErrorExitC in the Target-Programming-Language (TPL)
 
#define MkErrorExitCT   ( (struct MkTypeDefS *) MkErrorExitCTT )
 class as MkTypeDefS-class-type for MkErrorExitC in the Target-Programming-Language (TPL)
 
typedef struct MkErrorExitS libmkkernel::MkErrorExitCR
 instance-struct-reference same as struct MkErrorExitS, useable in a class-macro as: class##R
 
typedef const struct MkErrorExitS libmkkernel::MkErrorExitCNR
 const instance-struct-reference same as const struct MkErrorExitS, useable in a class-macro as: class##R
 

MkErrorIgnoreC - type definition

#define MkErrorIgnoreC_T   (&MK_RT_REF._MkErrorIgnoreC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkErrorIgnoreC_TT   (MkTYP(MkErrorIgnoreC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkErrorIgnoreST   MkErrorIgnoreC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkErrorIgnoreSTT   (MkTYP(MkErrorIgnoreST))
 instance-type as MkTypeS-class-type (cast from MkErrorIgnoreST into MkTypeS) …
 
#define MkErrorIgnoreCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkErrorIgnoreCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkErrorIgnoreCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkErrorIgnoreC_NS   MK
 map class to namespace …
 
#define MkErrorIgnoreCTT   MkErrorIgnoreCTT
 class as MkTypeS-class-type for MkErrorIgnoreC in the Target-Programming-Language (TPL)
 
#define MkErrorIgnoreCT   ( (struct MkTypeDefS *) MkErrorIgnoreCTT )
 class as MkTypeDefS-class-type for MkErrorIgnoreC in the Target-Programming-Language (TPL)
 
typedef struct MkErrorIgnoreS libmkkernel::MkErrorIgnoreCR
 instance-struct-reference same as struct MkErrorIgnoreS, useable in a class-macro as: class##R
 
typedef const struct MkErrorIgnoreS libmkkernel::MkErrorIgnoreCNR
 const instance-struct-reference same as const struct MkErrorIgnoreS, useable in a class-macro as: class##R
 

MkErrorPrintC - type definition

#define MkErrorPrintC_T   (&MK_RT_REF._MkErrorPrintC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkErrorPrintC_TT   (MkTYP(MkErrorPrintC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkErrorPrintST   MkErrorPrintC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkErrorPrintSTT   (MkTYP(MkErrorPrintST))
 instance-type as MkTypeS-class-type (cast from MkErrorPrintST into MkTypeS) …
 
#define MkErrorPrintCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkErrorPrintCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkErrorPrintCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkErrorPrintC_NS   MK
 map class to namespace …
 
#define MkErrorPrintCTT   MkErrorPrintCTT
 class as MkTypeS-class-type for MkErrorPrintC in the Target-Programming-Language (TPL)
 
#define MkErrorPrintCT   ( (struct MkTypeDefS *) MkErrorPrintCTT )
 class as MkTypeDefS-class-type for MkErrorPrintC in the Target-Programming-Language (TPL)
 
typedef struct MkErrorPrintS libmkkernel::MkErrorPrintCR
 instance-struct-reference same as struct MkErrorPrintS, useable in a class-macro as: class##R
 
typedef const struct MkErrorPrintS libmkkernel::MkErrorPrintCNR
 const instance-struct-reference same as const struct MkErrorPrintS, useable in a class-macro as: class##R
 

MkErrorDefaultC - type definition

#define MkErrorDefaultC_T   (&MK_RT_REF._MkErrorDefaultC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkErrorDefaultC_TT   (MkTYP(MkErrorDefaultC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkErrorDefaultST   MkErrorDefaultC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkErrorDefaultSTT   (MkTYP(MkErrorDefaultST))
 instance-type as MkTypeS-class-type (cast from MkErrorDefaultST into MkTypeS) …
 
#define MkErrorDefaultCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkErrorDefaultCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkErrorDefaultCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkErrorDefaultC_NS   MK
 map class to namespace …
 
#define MkErrorDefaultCTT   MkErrorDefaultCTT
 class as MkTypeS-class-type for MkErrorDefaultC in the Target-Programming-Language (TPL)
 
#define MkErrorDefaultCT   ( (struct MkTypeDefS *) MkErrorDefaultCTT )
 class as MkTypeDefS-class-type for MkErrorDefaultC in the Target-Programming-Language (TPL)
 
typedef struct MkErrorDefaultS libmkkernel::MkErrorDefaultCR
 instance-struct-reference same as struct MkErrorDefaultS, useable in a class-macro as: class##R
 
typedef const struct MkErrorDefaultS libmkkernel::MkErrorDefaultCNR
 const instance-struct-reference same as const struct MkErrorDefaultS, useable in a class-macro as: class##R
 

MkErrorDEFAULT

default-system-error - default-error

The default-error is defined once per runtime and is used as only-valid-source of an MkErrorC in a thread or process.

See also
ErrorFORMAT, ErrorPRINT, ErrorIGNORE, MkErrorPANIC, RMkNsRT{ErrorEXIT}
#define MK_ERROR_DEFAULT_R(r)
 return as libmkkernel::MK_OBJ, to return libmkkernel::MK_ERR use MkERROR (R,RT,O,X,XN) or MkErrorDEFAULT ...
 
#define MK_ERROR_DEFAULT   MK_ERROR_DEFAULT_R(&MK_RT_REF)
 
#define MK_ERROR_DEFAULT_X(x)
 
#define MK_ERROR_DEFAULT_NULL   MK_ERROR_DEFAULT_R(&MkRuntimeRLS)
 
static MK_ERR libmkkernel::MkErrorDEFAULT_RT (MK_RT mkrt)
 default-system-error - default-error
 

MkErrorPanik

panic-system-error - panic on next error …

If the panic-system-error is used as the format-obj of an error-message, the text is formated as usual, but the default-error is not set, instead a MkPanicVL is called and the application terminates.

MkErrorPANIC - usage

Set the MkErrorS::format_of_error attribute to PANIC. The next error-message will be formated as usual and than be reported using MkPanicVL. With MkPanicVL the error will be printed to MkLogFileC (default: stderr) and the application will abort.

Returns
the default-error with MkErrorS::format_of_error attribute set
See also
ErrorDEFAULT, ErrorPRINT, ErrorIGNORE, MkErrorPANIC, RMkNsRT{ErrorEXIT}
#define MK_ERROR_PANIC_R(r)
 
#define MK_ERROR_PANIC   MK_ERROR_PANIC_R(&MK_RT_REF)
 
#define MK_ERROR_PANIC_X(x)
 
#define MK_ERROR_PANIC_NULL   MK_ERROR_PANIC_R(&MkRuntimeRLS)
 use MkRuntimeRLS as runtime
 
static MK_ERR libmkkernel::MkErrorPANIC_RT (MK_RT mkrt)
 panic-system-error - panic on next error …
 

MkErrorExit

panic-system-error - panic on next error …

If the panic-system-error is used as the format-obj of an error-message, the text is formated as usual, but the default-error is not set, instead a MkPanicVL is called and the application terminates.

MkErrorEXIT - usage

Set the MkErrorS::format_of_error attribute to EXIT. The next error-message will be formated as usual and than be reported using MkPanicVL. With MkPanicVL the error will be printed to MkLogFileC (default: stderr) and the application will abort.

Returns
the default-error with MkErrorS::format_of_error attribute set
See also
ErrorDEFAULT, ErrorPRINT, ErrorIGNORE, MkErrorEXIT
#define MK_ERROR_EXIT_R(r)
 
#define MK_ERROR_EXIT   MK_ERROR_EXIT_R(&MK_RT_REF)
 
#define MK_ERROR_EXIT_X(x)
 
#define MK_ERROR_EXIT_NULL   MK_ERROR_EXIT_R(&MkRuntimeRLS)
 use MkRuntimeRLS as runtime
 
static MK_ERR libmkkernel::MkErrorEXIT_RT (MK_RT mkrt)
 panic-system-error - panic on next error …
 

MkErrorIgnore

ignore-system-error - ignore the next error …

The next error will be ignored, no formatting will be performed and the the default-error will not be modified.

MkErrorIGNORE - usage

There are two functions to suppress an error: MkErrorIGNORE and MkErrorNoRaise.

MkErrorIGNORE
Set the MkErrorS::format_of_error attribute to IGNORE. The next error will be ignored, no formatting will be performed and the the default-error will not be modified.
MkErrorNoRaise
Set the MkErrorS::noRaise attribute to TRUE. The next error will be set as usual but not raised. This is usefull to set an error and later append additional information to the error. Final the error have to be raised with MkErrorRaise.
Returns
the default-error with MkErrorS::format_of_error attribute set
See also
ErrorDEFAULT, ErrorPRINT, ErrorIGNORE, MkErrorPANIC, RMkNsRT{ErrorEXIT}
#define MK_ERROR_IGNORE_R(r)
 
#define MK_ERROR_IGNORE   MK_ERROR_IGNORE_R(&MK_RT_REF)
 
#define MK_ERROR_IGNORE_X(x)
 
#define MK_ERROR_IGNORE_XN(x)
 
#define MK_ERROR_IGNORE_NULL   MK_ERROR_IGNORE_R(&MkRuntimeRLS)
 use MkRuntimeRLS as runtime
 
static MK_ERR libmkkernel::MkErrorIGNORE_RT (MK_RT mkrt)
 ignore-system-error - ignore the next error …
 

MkErrorPrintln

ignore-system-error - print the next error into MkLogFileC

The next error-message will be formated as usual and than be reported using MkLogVL. The default-error will not be modified.

MkErrorPRINT - usage

Set the MkErrorS::format_of_error attribute to PRINT.

Returns
the default-error with MkErrorS::format_of_error attribute set
See also
ErrorDEFAULT, ErrorPRINT, ErrorIGNORE, MkErrorPANIC, RMkNsRT{ErrorEXIT}
#define MK_ERROR_PRINT_R(r)
 
#define MK_ERROR_PRINT   MK_ERROR_PRINT_R(&MK_RT_REF)
 
#define MK_ERROR_PRINT_X(x)
 
#define MK_ERROR_PRINT_NULL   MK_ERROR_PRINT_R(&MkRuntimeRLS)
 use MkRuntimeRLS as runtime
 
static MK_ERR libmkkernel::MkErrorPRINT_RT (MK_RT mkrt)
 ignore-system-error - print the next error into MkLogFileC
 

MkErrorFORMAT

system-error-format - format and return the default-error

Returns
the MkErrorS::format_of_error or MkErrorS::source_of_error attribute

MkErrorFORMAT - usage

Set the MkErrorS::format_of_error attribute to fmtobj or MK_NULL. The next error-message will be formated as usual and than be raised as error. The default-error will be modified.

The next error-message created with ErrorSetC etc is formatted with MkRuntimeS->cid ("context-in-duty") or simply as "DEFAULT" if cid == NULL.

Parameters
[in]fmtobjmanaged object used to format the log-message (default=MK_NULL → use default-format)
Returns
the default-error with MkErrorS::format_of_error attribute set
See also
ErrorDEFAULT, ErrorPRINT, ErrorIGNORE, MkErrorPANIC, RMkNsRT{ErrorEXIT}
#define MK_ERROR_FORMAT_R(r)
 
#define MK_ERROR_FORMAT   MK_ERROR_FORMAT_R(&MK_RT_REF)
 
#define MK_ERROR_FORMAT_X(x)
 
#define MK_ERROR_FORMAT_NULL   MK_ERROR_FORMAT_R(&MkRuntimeRLS)
 use MkRuntimeRLS as runtime
 
#define MkErrorFORMAT_1M(m)
 
#define MkErrorFORMAT_1X(x)
 
#define MkErrorFORMAT_1O(o)
 
MK_ERR libmkkernel::MkErrorFORMAT (MK_OBJN fmtobj)
 system-error-format - format and return the default-error
 
MK_ERR libmkkernel::MkErrorFORMAT_EO (MK_OBJN fmtobj)
 same as [static] MkErrorC* MkErrorC::DEFAULT() but do not set the MkERROR.format_of_error attribute on errobj==NULL
 

MkRtExtC - type definition

#define MkRtExtC_T   (&MK_RT_REF._MkRtExtC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkRtExtC_TT   (MkTYP(MkRtExtC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkRtExtST   MkRtExtC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkRtExtSTT   (MkTYP(MkRtExtST))
 instance-type as MkTypeS-class-type (cast from MkRtExtST into MkTypeS) …
 
#define MkRtExtC_type   MK_RTEXT
 same as MkRtExtS but useable in a class-macro as: class##_type
 
#define MkRtExtCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkRtExtCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkRtExtCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkRtExtC_NS   MK
 map class to namespace …
 
#define MkRtExtCTT   MkRtExtCTT
 class as MkTypeS-class-type for MkRtExtC in the Target-Programming-Language (TPL)
 
#define MkRtExtCT   ( (struct MkTypeDefS *) MkRtExtCTT )
 class as MkTypeDefS-class-type for MkRtExtC in the Target-Programming-Language (TPL)
 
typedef struct MkRtExtS libmkkernel::MkRtExtCR
 instance-struct-reference same as struct MkRtExtS, useable in a class-macro as: class##R
 
typedef const struct MkRtExtS libmkkernel::MkRtExtCNR
 const instance-struct-reference same as const struct MkRtExtS, useable in a class-macro as: class##R
 

MkRtExtC - signature check

#define MkRtExtC_Check(mng)
 
static bool libmkkernel::MkRtExtCheck (MK_MNGN mng)
 check MkRtExtS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkRtExtCheckO (MK_OBJN obj)
 check MkRtExtS -> libmkkernel::MkObjectS::signature
 

MkRtExtC - cast from a defined or a undefined instance

#define MkRtExtRaise(_rtext)
 raise an error if class-instance is not valid
 
#define MkRTEXT_R(x)
 cast a known-object into an MkRtExtS reference
 
#define MkRTEXT(x)
 cast a known-object into an MkRtExtS pointer
 
static MK_RTEXT libmkkernel::MkRtExt (MK_MNG mng)
 cast a unknown-object into an MkRtExtS pointer or NULL if not possible
 
static MK_RTEXTN libmkkernel::MkRtExtN (MK_MNGN mng)
 (const) cast a unknown-object into an MkRtExtS pointer or NULL if not possible
 

MkRuntimeC - type definition

#define MkRuntimeC_T   (&MK_RT_REF._MkRuntimeC_T)
 class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
 
#define MkRuntimeC_TT   (MkTYP(MkRuntimeC_T))
 class as MkTypeS-class-type, useable in a class-macro as: class##_TT
 
#define MkRuntimeST   MkRuntimeC_T
 instance-type as MkTypeDefS-class-type …
 
#define MkRuntimeSTT   (MkTYP(MkRuntimeST))
 instance-type as MkTypeS-class-type (cast from MkRuntimeST into MkTypeS) …
 
#define MkRuntimeC_type   MK_RT
 same as MkRuntimeS but useable in a class-macro as: class##_type
 
#define MkRuntimeCT_X(instance)
 cast from an instance into the MkTypeDefS-class-type …
 
#define MkRuntimeCTT_X(instance)
 cast from an instance into the MkTypeS-class-type …
 
#define MkRuntimeCT_TT(typ)
 cast from an MkTypeS-class-type into an MkTypeDefS-class-type …
 
#define MkRuntimeC_NS   MK
 map class to namespace …
 
#define MkRuntimeCTT   MkRuntimeCTT
 class as MkTypeS-class-type for MkRuntimeC in the Target-Programming-Language (TPL)
 
#define MkRuntimeCT   ( (struct MkTypeDefS *) MkRuntimeCTT )
 class as MkTypeDefS-class-type for MkRuntimeC in the Target-Programming-Language (TPL)
 
typedef struct MkRuntimeS libmkkernel::MkRuntimeCR
 instance-struct-reference same as struct MkRuntimeS, useable in a class-macro as: class##R
 
typedef const struct MkRuntimeS libmkkernel::MkRuntimeCNR
 const instance-struct-reference same as const struct MkRuntimeS, useable in a class-macro as: class##R
 

MkRuntimeC - signature check

#define MkRuntimeC_Check(mng)
 
static bool libmkkernel::MkRtCheck (MK_MNGN mng)
 check MkRuntimeS -> libmkkernel::MkObjectS::signature
 
static bool libmkkernel::MkRtCheckO (MK_OBJN obj)
 check MkRuntimeS -> libmkkernel::MkObjectS::signature
 

MkRuntimeC - cast from a defined or a undefined instance

#define MkRtRaise(_rt)
 raise an error if class-instance is not valid
 
static MK_RT libmkkernel::MkRt (MK_MNG mng)
 cast a unknown-object into an MkRuntimeS pointer or NULL if not possible
 
static MK_RTN libmkkernel::MkRtN (MK_MNGN mng)
 (const) cast a unknown-object into an MkRuntimeS pointer or NULL if not possible
 

MkRuntimeC - Export - inline - interact with an external software

#define MkRuntimeHandleResolve_e(netHdl)
 wrapper for MkRuntimeHandleResolve with error-handline
 
static MK_HDL libmkkernel::MkRuntimeHandleGet_RT (MK_RT mkrt, MK_RT const rt)
 Handle-Get-Slot - returns a export-hdl to the MkRuntimeC useable for external storage
 
static MK_RT libmkkernel::MkRuntimeHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
 Handle-Resolve-Slot - return a MkRuntimeC from netHdl or MK_NULL if invalid…
 

MkErrorE

enum  libmkkernel::MkErrorE { libmkkernel::MK_OK = 0 , libmkkernel::MK_CONTINUE = 1 , libmkkernel::MK_ERROR = 2 }
 collection for the different error-codes … More...
 
MK_STRN libmkkernel::MkErrorE_ToString (enum MkErrorE value)
 return the MkErrorE as string …
 
static MK_I32 libmkkernel::MkErrorE_ToInt (enum MkErrorE value)
 return the MkErrorE as integer …
 
enum MkErrorE libmkkernel::MkErrorE_FromInt (MK_I32 const value, enum MkErrorE *value_out)
 return the MkErrorE from integer …
 

MkTimeoutE

enum  libmkkernel::MkTimeoutE {
  libmkkernel::MK_TIMEOUT_INIT = META_TIMEOUT_REF , libmkkernel::MK_TIMEOUT_LONG = (META_TIMEOUT_REF/5) , libmkkernel::MK_TIMEOUT_NORMAL = (META_TIMEOUT_REF/10 < 1 ? 1 : META_TIMEOUT_REF/10) , libmkkernel::MK_TIMEOUT_SHORT = (META_TIMEOUT_REF/45 < 1 ? 1 : META_TIMEOUT_REF/45) ,
  libmkkernel::MK_TIMEOUT_SOCKET = (META_TIMEOUT_REF/90 < 1 ? 1 : META_TIMEOUT_REF/90) , libmkkernel::MK_TIMEOUT_VERYSHORT = (META_TIMEOUT_REF/180 < 1 ? 1 : META_TIMEOUT_REF/180) , libmkkernel::MK_TIMEOUT_DEFAULT = -1 , libmkkernel::MK_TIMEOUT_USER = -2 ,
  libmkkernel::MK_TIMEOUT_MAX = -3
}
 Predefined Timeout values … More...
 
MK_STRN libmkkernel::MkTimeoutE_ToString (enum MkTimeoutE value)
 return the MkTimeoutE as string …
 
static MK_I32 libmkkernel::MkTimeoutE_ToInt (enum MkTimeoutE value)
 return the MkTimeoutE as integer …
 
enum MkErrorE libmkkernel::MkTimeoutE_FromInt (MK_I32 const value, enum MkTimeoutE *value_out)
 return the MkTimeoutE from integer …
 

MkBoolE

enum  libmkkernel::MkBoolE { libmkkernel::MK_NO = 0 , libmkkernel::MK_YES = 1 }
 the internal boolean … More...
 
MK_STRN libmkkernel::MkBoolE_ToString (enum MkBoolE value)
 return the MkBoolE as string …
 
static MK_I32 libmkkernel::MkBoolE_ToInt (enum MkBoolE value)
 return the MkBoolE as integer …
 
enum MkErrorE libmkkernel::MkBoolE_FromInt (MK_I32 const value, enum MkBoolE *value_out)
 return the MkBoolE from integer …
 

MkNativeIsE

enum  libmkkernel::MkNativeIsE { libmkkernel::MK_NATIVE_IS_INITIAL = 0 , libmkkernel::MK_NATIVE_IS_STRING = 'S' , libmkkernel::MK_NATIVE_IS_LITTLE = 'L' , libmkkernel::MK_NATIVE_IS_BIG = 'B' }
 define if data is string or little or big endian … More...
 
MK_STRN libmkkernel::MkNativeIsE_ToString (enum MkNativeIsE value)
 return the MkNativeIsE as string …
 
static MK_I32 libmkkernel::MkNativeIsE_ToInt (enum MkNativeIsE value)
 return the MkNativeIsE as integer …
 
enum MkErrorE libmkkernel::MkNativeIsE_FromInt (MK_I32 const value, enum MkNativeIsE *value_out)
 return the MkNativeIsE from integer …
 

primitive string data-type

typedef char libmkkernel::MK_STRB
 string type data-type
 
typedef MK_STRBlibmkkernel::MK_STR
 string pointer data-type with UTF8 ecoding (MK_STR)
 
typedef const MK_STRBlibmkkernel::MK_STRN
 constant string pointer data-type
 
typedef MK_STRB const * libmkkernel::MK_FST
 const format string pointer data-type
 
MK_UNUSED static const MK_STRN_A libmkkernel::MK_STRN_A_NULL = (MK_STRN_A) {0,0}
 

MkRuntimeCallback

Register callback used to setup library-local runtime attributes …

Sometimes the features provided by MkRuntimeRLS are not fullfilling the requirements of the implementation. Sometimes the functions provided by the MkRuntimeRLS do not meet the implementation requirements. Two methods are offered to retrofit the missing capability:

Example from "LibLcConfig_jv.c": add a runtime-callback to implement a specific type.
// LC classes
MkThreadLocal MK_TYP LcConfigC_TT = NULL;
MkThreadLocal MK_TYP LcSettingC_TT = NULL;
...
static MkRuntimeCallbackS sLcRuntimeCallback = {0};
...
static void sConfigRuntimeCallback ( struct MkRuntimeS * mkrt ) {
LcConfigC_TT = MkTypeCreate(LcConfigC, MkObjectC, "LcConfigC");
LcConfigC_TT->constructor = pConfigCreate;
LcConfigC_TT->destructor = pConfigDelete;
LcSettingC_TT = MkTypeCreate(LcSettingC, MkObjectC, "LcSettingC");
LcSettingC_TT->constructor = pSettingCreate;
LcSettingC_TT->destructor = pSettingDelete;
if (LcSetupThread) {
(*LcSetupThread)(MK_RT_CALL_ONLY);
}
}
...
void LcSetup(void) {
...
sLcRuntimeCallback.mkrt = mkrt;
sLcRuntimeCallback.cb = NS(sLcRuntimeCallback);
// class specific initialization
MkRuntimeCallbackAdd( &sLcRuntimeCallback );
...
}
#define MkThreadLocal
size_t MkRuntimeCallbackAdd(MK_RT mkrt, MkRuntimeCallbackS *cbdata, MkRuntimeInitF rt_callback, MK_STRN ident)
add a callback to the runtime …
#define MK_RT_CALL_ONLY
#define MkTypeCreate(clsV, basicV, identV)
typedef struct libmkkernel::MkRuntimeCallbackS libmkkernel::MkRuntimeCallbackS
 keep callback related data …
 
size_t libmkkernel::MkRuntimeCallbackAdd (MK_RT mkrt, MkRuntimeCallbackS *cbdata, MkRuntimeInitF rt_callback, MK_STRN ident)
 add a callback to the runtime
 
void libmkkernel::MkRuntimeCallbackDel (MK_RT mkrt, MkRuntimeCallbackS *cbdata)
 delete a callback from the runtime
 

Macro Definition Documentation

◆ check_MkErrorE

#define check_MkErrorE ( PROC)
Value:
if (MkErrorCheckI(PROC))
#define MkErrorCheckI(err)

check MkErrorE macro …

Definition at line 11166 of file LibMkKernel_mk.h.

◆ META_DEBUG_ALL

#define META_DEBUG_ALL   -1 /* The C standard guarantees that assigning -1 sets all bits. */

Definition at line 292 of file LibMkKernel_mk.h.

◆ META_DEBUG_CACHE

#define META_DEBUG_CACHE   (1<<2)

Definition at line 294 of file LibMkKernel_mk.h.

◆ META_DEBUG_DEFAULT

#define META_DEBUG_DEFAULT   (1<<1)

Definition at line 293 of file LibMkKernel_mk.h.

◆ META_DEBUG_ERROR

#define META_DEBUG_ERROR   (1<<8)

Definition at line 313 of file LibMkKernel_mk.h.

◆ META_DEBUG_ERROR_check

#define META_DEBUG_ERROR_check ( )

raise worning if function is call with ACTIVE error set

Definition at line 331 of file LibMkKernel_mk.h.

◆ META_DEBUG_ERROR_checkO

#define META_DEBUG_ERROR_checkO ( o)

Definition at line 333 of file LibMkKernel_mk.h.

◆ META_DEBUG_ERROR_checkX

#define META_DEBUG_ERROR_checkX ( x)

Definition at line 332 of file LibMkKernel_mk.h.

◆ META_DEBUG_EVENT

#define META_DEBUG_EVENT   (1<<5)

Definition at line 304 of file LibMkKernel_mk.h.

◆ META_DEBUG_MEM

#define META_DEBUG_MEM   (1<<6)

Definition at line 305 of file LibMkKernel_mk.h.

◆ META_DEBUG_REFCOUNT

#define META_DEBUG_REFCOUNT   (1<<7)

Definition at line 312 of file LibMkKernel_mk.h.

◆ META_DEBUG_SOCKET

#define META_DEBUG_SOCKET   (1<<4)

Definition at line 303 of file LibMkKernel_mk.h.

◆ META_DEBUG_TYPE

#define META_DEBUG_TYPE   (1<<3)

Definition at line 295 of file LibMkKernel_mk.h.

◆ META_DEBUG_TYPE__printV

#define META_DEBUG_TYPE__printV ( ...)

Definition at line 322 of file LibMkKernel_mk.h.

◆ META_DOXYGEN_USE_C_PRIVAT

#define META_DOXYGEN_USE_C_PRIVAT   0

Definition at line 267 of file LibMkKernel_mk.h.

◆ META_HDL_USE__NONNULL__GCC_ATTRIBUTE

#define META_HDL_USE__NONNULL__GCC_ATTRIBUTE   0

Definition at line 213 of file LibMkKernel_mk.h.

◆ META_TIMEOUT_REF

#define META_TIMEOUT_REF   900

Definition at line 206 of file LibMkKernel_mk.h.

◆ META_USE_SELF_REFCOUNT

#define META_USE_SELF_REFCOUNT

Definition at line 411 of file LibMkKernel_mk.h.

◆ MkCacheItemS_signature

#define MkCacheItemS_signature   0x44196912

Definition at line 2309 of file LibMkKernel_mk.h.

◆ MkCacheS_MkCacheItemS_size

#define MkCacheS_MkCacheItemS_size   8

Definition at line 2337 of file LibMkKernel_mk.h.

◆ MkCacheS_name_size

#define MkCacheS_name_size   32

Definition at line 2327 of file LibMkKernel_mk.h.

◆ MkContinueCheck

#define MkContinueCheck ( err)
Value:
switch (err) { \
case MK_OK: break; case MK_CONTINUE: goto cont; case MK_ERROR: goto error;\
};

check on MK_ERROR and MK_CONTINUE - jump to label …

Definition at line 11133 of file LibMkKernel_mk.h.

11133if (MkErrorCheckI(PROC)) { \
11134 return MkErrorStack_0E (); \
11135} else if (MkErrorCheckE_0E()) { \
#define MkErrorCheckE_0E()
#define MkErrorStack_0E()

◆ MkErrorBreak

#define MkErrorBreak ( err)
Value:
if (MkErrorCheckI(err)) break

check return-code and break on error …

Definition at line 11131 of file LibMkKernel_mk.h.

◆ MkErrorCheck

#define MkErrorCheck ( err)
Value:
if (MkErrorCheckI(err)) goto error

check return-code and goto error on error …

Definition at line 11125 of file LibMkKernel_mk.h.

◆ MkErrorCheck_0E

#define MkErrorCheck_0E ( )
Value:
if (MkErrorCheckE_0E()) goto error

check return-code and goto error on error …

Definition at line 11129 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_0E

#define MkErrorCheckE_0E ( )
Value:

Definition at line 11118 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_E

#define MkErrorCheckE_E ( e)
Value:
(MkErrorCheckI((e)->code))

Definition at line 11122 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_NULL

#define MkErrorCheckE_NULL ( )
Value:
#define MkErrorGetCodeE_NULL()
get the value of MkErrorS::code …

Definition at line 11119 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_O

#define MkErrorCheckE_O ( o)
Value:
#define MkErrorGetCode_O(o)
get the value of MkErrorS::code …

Definition at line 11120 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_X

#define MkErrorCheckE_X ( x)
Value:
#define MkErrorCheckE_O(o)
#define MkOBJ(x)
cast a known-object into an MkObjectS pointer

Definition at line 11121 of file LibMkKernel_mk.h.

◆ MkErrorCheckI

#define MkErrorCheckI ( err)
Value:
((err) >= MK_ERROR)
Returns
0(no) on libmkkernel::MK_OK and libmkkernel::MK_CONTINUE and an 1(yes) libmkkernel::MK_ERROR

Definition at line 11114 of file LibMkKernel_mk.h.

◆ MkErrorE_Check

#define MkErrorE_Check ( err)
Value:
if (MkErrorCheckI(err)) goto error

check return-code and goto error on error …

Definition at line 11127 of file LibMkKernel_mk.h.

◆ MkErrorReturn

#define MkErrorReturn ( PROC)
Value:
#define META_CONTEXT_S
#define MkErrorReturn_2X(mngx, PROC)
process error message …

process error message …

Definition at line 11164 of file LibMkKernel_mk.h.

◆ MkErrorReturn_1

#define MkErrorReturn_1 ( PROC)
Value:
switch (PROC) {\
case MK_OK: return MK_OK; case MK_CONTINUE: return MK_CONTINUE; default: return MkErrorStack_0E ();\
};

process error message …

Definition at line 11160 of file LibMkKernel_mk.h.

11160
11161// MkErrorCheck...
11162

◆ MkErrorReturn_2X

#define MkErrorReturn_2X ( mngx,
PROC )
Value:
switch (PROC) {\
case MK_OK: return MK_OK; case MK_CONTINUE: return MK_CONTINUE; default: return MkErrorStack_1X (mngx);\
};
#define MkErrorStack_1X(...)

process error message …

Definition at line 11156 of file LibMkKernel_mk.h.

11156 return MK_OK; \
11157error: \
11158 return MkErrorStack_1M(mng);
#define MkErrorStack_1M(err)
@ MK_OK
(persistent) everything is OK.

◆ MkErrorReturnLabel

#define MkErrorReturnLabel ( mng)
Value:
return MK_OK; \
error: \
return MkErrorStack_1M(mng);

default return from function with error-label set …

Definition at line 11169 of file LibMkKernel_mk.h.

11169
11171
11172__parser__global__(prefix2class:MkPanic=MkErrorC);
#define __parser__global__(...)
parser: apply an attribute to a dunction in global scope …

◆ MkErrorSwitch

#define MkErrorSwitch ( PROC)
Value:
switch (PROC) {\
case MK_OK: break; case MK_ERROR: goto error; case MK_CONTINUE: return MK_CONTINUE;\
}

process error message …

Definition at line 11138 of file LibMkKernel_mk.h.

11138 return MkERROR.code; \
11139}
11140*/
#define MkERROR

◆ MkLogDataEA

#define MkLogDataEA ( e)
Value:
e

Definition at line 9098 of file LibMkKernel_mk.h.

◆ MkLogDataS_LogNAME_size

#define MkLogDataS_LogNAME_size   256

append to logFILE, valid values are: stderr, stdout or a filename (default: stderr)

Definition at line 9111 of file LibMkKernel_mk.h.

◆ MkRuntimeCallbackS_ident_size

#define MkRuntimeCallbackS_ident_size   30

Definition at line 12556 of file LibMkKernel_mk.h.

◆ MkTypeS_name_size

#define MkTypeS_name_size   32

Definition at line 3955 of file LibMkKernel_mk.h.