#include "debug_mk.h"
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
#include <time.h>
#include <limits.h>
#include <string.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.

Data Structures
struct	MK_STRN_A
	array of MK_STRN values … More...

struct	MkBinaryR
	binary data default format … More...

struct	MkStringR
	string data default format … More...

union	MkBufferAtomU
	union used to set or modify native data from an MkBufferS object … More...

union	MkBufferU
	a union for all data items supported by MkBufferS … More...

struct	MkIdS
	data type for process/thread identification … More...

struct	MkCacheItemS
	a linked-list to opearate a storage of data items More...

struct	MkCacheS
	This is an circel storage of a linked-list connected with a "lock" at MkCacheS … More...

struct	MkLalS
	Interface between libmkkernel and the Operating-System … More...

struct	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	MkObjectS
	object header … More...

struct	MkAllocDefS
	define the storage-allocator function More...

struct	MkTypeS
	MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type … More...

struct	MkSuperTypeS
	super-class-base, the MkTypeS using the super-macro-syntax for all non specific types … More...

struct	MkBufferS
	The ABSTRACT-CLASS used to store a native-type-data-item defined by PRIMITIVE TYPE … More...

struct	MkBufferS::ilsS
	instance storage predefined More...

struct	MkBuffer64S
	the final class of MkBufferS with 64 byte ILS-Size … More...

struct	MkBuffer256S
	the final class of MkBufferS with 256 byte ILS-Size … More...

struct	MkBuffer1024S
	the final class of MkBufferS with 1024 byte ILS-Size … More...

struct	MkBufferStreamS
	The ABSTRACT-CLASS MkBufferStreamS is used for package-based serialized IO … More...

struct	MkBufferStream64S
	the final class of MkBufferStreamS with 64 byte ILS-Size … More...

struct	MkBufferStream256S
	the final class of MkBufferStreamS with 256 byte ILS-Size … More...

struct	MkBufferStream1024S
	the final class of MkBufferStreamS with 1024 byte ILS-Size … More...

struct	MkBufferStream16384S
	the final class of MkBufferStreamS with 16384 byte ILS-Size … More...

struct	MkLogFileS
	define a MkLogFileC object … More...

struct	MkExtensionS
	Base class for the extension technologie … More...

struct	MkErrorS
	The data-type to store and handle the error-condition … More...

struct	MkErrExtS
	extension-slot for MkErrorS … More...

struct	MkErrorPanicS
	signal-slot for panic on error … More...

struct	MkErrorIgnoreS
	signal-slot for ignore on error … More...

struct	MkErrorPrintS
	signal-slot for print on error … More...

struct	MkErrorDefaultS
	signal-slot for raise an error … More...

struct	MkRtExtS
	MkRtExtS - extend the MkRuntimeC with a library specific feature … More...

struct	MkRuntimeS
	The MkRuntimeS provide a per-thread environment for libmkkernel … More...

struct	MkRuntimeCallbackS
	keep callback related data … More...

Macros

#define META_TIMEOUT_REF 900

#define META_HDL_USE__NONNULL__GCC_ATTRIBUTE 0

#define META_TYPE_DEBUG 0

#define META_TYPE_DEBUG__printV(...)

#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_XN(x)

#define MK_INSTANCE_RT_O(o)

#define MK_INSTANCE_RT_ON(o)

#define MK_DESTRUCTOR_RT_X(c, x)

#define MK_STATIC_RT MkRtSetup_NULL_RT

#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 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 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 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 MkObjectDeleteCallF

#define MkObjectDeleteCallF_ARGS

the 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 MkObjectDeleteFreeF arguments with default names

#define MkTypeCreate(clsV, basicV, identV)

#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 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 MkDDInit const MK_I32 __dbg = MK_RT_REF.debug

#define MkDDInitNum(n)

#define MkLogHEX_4X(fmtobj, callfunc, data, len)

#define MkObjectLogSimple_1X(x)

#define MkObjectLogDetail_1X(x)

#define MkObjectLogDetail_1M(m)

#define MkObjectLog_1X(x)

#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 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)

#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 MkExtension_size 64

maximum number of runtime-extensions useable in a theKernel software.

#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 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 MkObjectErrorCatch_3X(x, ...)

inline for MkObjectErrorCatch …

#define MkErrorReset_0M()

#define MkErrorResetFORCE(m)

#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 MkRuntimeCallbackS_ident_size 30

#define MkObjectToError_1X(obj)

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_CDECL

#define BEGIN_MK_C_DECLS /* empty */

#define END_MK_C_DECLS /* empty */

#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

dosable "MK_NO_RETURN" because C# require "return" from "MqExit" for thread-pool support

#define MK_UNREACHABLE __builtin_unreachable()

#define MK_ARTIFICIAL __attribute__((__artificial__))

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 ^ (10u<<10))

#define MkTypeC_MASK (((1u<<22)-1)<<10)

MkTypeC - cast to superclass

#define MkTypeC_X2typ(x)

#define MkTypeC_X2obj(x)

MkSuperTypeC - signature define

#define MkSuperTypeC_SIGNATURE (MkTypeC_SIGNATURE ^ (1u<<6))

#define MkSuperTypeC_MASK (((1u<<26)-1)<<6)

MkSuperTypeC - cast to superclass

#define MkSuperTypeC_X2typ(x)

#define MkSuperTypeC_X2obj(x)

MkObjectC - MkObjectC_Obj_C_API - overload

#define MkRefCidN_NULL()

evaluate CODE in debug …

_debug

#define MkDCheck(_debug)

#define MkDDCheck(_debug)

log a plain string …

Parameters

[in]	fmtobj	managed object used to format the log-message (default=`MK_NULL` → use default-format) _debug
	str	the 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]	fmtobj	managed object used to format the log-message (default=`MK_NULL` → use default-format) _debug
[in]	printfmt	is 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, ...)

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 ^ (8u<<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)

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 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] mngx the MkObjectS instance to work on

Returns: an boolean values… true or false

#define MkErrorCheckI(err)

MkErrorCheck

Returns: on MK_OK and MK_CONTINUE return 0 and an MK_ERROR return 1

#define MkErrorCheckE_0E()

#define MkErrorCheckE_NULL()

#define MkErrorCheckE_O(o)

#define MkErrorCheckE_X(x)

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 ^ (9u<<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 *	MK_MACRO_TYP
	helper-type used to declare a prototype for a macro

typedef struct MkObjectS *	MK_OBJ
	class-shortcut for `struct MkObjectS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkObjectS *	MK_OBJN
	class-shortcut for `const struct MkObjectS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkObjectS	MK_OBJR
	reference-shortcut for `struct MkObjectS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkBufferS *	MK_BUF
	class-shortcut for `struct MkBufferS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkBufferS *	MK_BUFN
	class-shortcut for `const struct MkBufferS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkBufferS	MK_BUFR
	reference-shortcut for `struct MkBufferS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkBufferStreamS *	MK_BUS
	class-shortcut for `struct MkBufferStreamS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkBufferStreamS *	MK_BUSN
	class-shortcut for `const struct MkBufferStreamS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkBufferStreamS	MK_BUSR
	reference-shortcut for `struct MkBufferStreamS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkBufferListS *	MK_BFL
	class-shortcut for `struct MkBufferListS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkBufferListS *	MK_BFLN
	class-shortcut for `const struct MkBufferListS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkBufferListS	MK_BFLR
	reference-shortcut for `struct MkBufferListS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkLogFileS *	MK_LFL
	class-shortcut for `struct MkLogFileS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkLogFileS *	MK_LFLN
	class-shortcut for `const struct MkLogFileS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkLogFileS	MK_LFLR
	reference-shortcut for `struct MkLogFileS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkErrorS *	MK_ERR
	class-shortcut for `struct MkErrorS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkErrorS *	MK_ERRN
	class-shortcut for `const struct MkErrorS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkErrorS	MK_ERRR
	reference-shortcut for `struct MkErrorS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkExtensionS *	MK_EXT
	class-shortcut for `struct MkExtensionS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkExtensionS *	MK_EXTN
	class-shortcut for `const struct MkExtensionS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkExtensionS	MK_EXTR
	reference-shortcut for `struct MkExtensionS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkErrExtS *	MK_ERREXT
	class-shortcut for `struct MkErrExtS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkErrExtS *	MK_ERREXTN
	class-shortcut for `const struct MkErrExtS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkErrExtS	MK_ERREXTR
	reference-shortcut for `struct MkErrExtS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkRtExtS *	MK_RTEXT
	class-shortcut for `struct MkRtExtS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkRtExtS *	MK_RTEXTN
	class-shortcut for `const struct MkRtExtS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkRtExtS	MK_RTEXTR
	reference-shortcut for `struct MkRtExtS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkRuntimeS *	MK_RT
	class-shortcut for `struct MkRuntimeS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkRuntimeS *	MK_RTN
	class-shortcut for `const struct MkRuntimeS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkRuntimeS	MK_RTR
	reference-shortcut for `struct MkRuntimeS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkTypeS *	MK_TYP
	class-shortcut for `struct MkTypeS *`, all shortcut using the `XX_YYY` syntax (only for public API) …

typedef const struct MkTypeS *	MK_TYPN
	class-shortcut for `const struct MkTypeS `, all const* shortcut using the `XX_YYYC` syntax (only for public API) …

typedef struct MkTypeS	MK_TYPR
	reference-shortcut for `struct MkTypeS`, all shortcut using the `XX_YYYR` syntax (only for public API) …

typedef struct MkBufferListS *	MK_BAC
	a list of 'buffer' as last argument in function …

typedef const struct MkBufferListS *	MK_BACN
	const - a list of 'buffer' as last argument in function …

typedef uintptr_t	MK_IDNT
	process or thread identifier …

typedef MK_PTR(*	MkCacheCF) (MK_RT mkrt, MK_PTR const)

typedef void(*	MkCacheDF) (MK_RT mkrt, MK_PTR *const)

typedef void(*	MkMarkF) (MK_RT mkrt, MK_PTR data)
	prototype for a Garbage-Collection mark function …

typedef MK_PTR(*	MkSysCallocF) (size_t, size_t)
	calloc syscall …

typedef MK_PTR(*	MkSysMallocF) (size_t)
	malloc syscall …

typedef MK_STR(*	MkSysStrDupF) (MK_STRN)
	strdup syscall …

typedef MK_STR(*	MkSysStrNCpyF) (char , const char , size_t)
	strdup strncpy …

typedef MK_STR(*	MkSysStrNDupF) (MK_STRN, size_t)
	strndup syscall …

typedef MK_PTR(*	MkSysReallocF) (MK_PTR, size_t)
	realloc syscall …

typedef void(*	MkSysFreeF) (MK_PTR)
	free syscall …

typedef pid_t(*	MkSysForkF) (void)
	fork syscall …

typedef enum MkErrorE(*	MkSysWaitF) (MK_OBJN const fmtobj, MK_IDNT const id)
	wait for process to finish syscall with libmkkernel error plugin

typedef void(*	MkSysExitF) (MK_RT mkrt, int isThread, int num) MK_NO_RETURN
	exit syscall with libmkkernel error plugin

typedef enum MkSysPipeHandlerE	MkSysPipeHandlerE

typedef enum MkErrorE(*	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(*	MkObjectDeleteFreeF) (MkObjectDeleteFreeF_ARGS)

typedef struct MkBufferStream16384S	MkBufferStream16384R
	reference type of MkBufferStream16384S

typedef struct MkExtensionS	MkExtensionS
	Base class for the extension technologie …

typedef bool(*	MkErrorAppendFLT) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)

typedef void(*	MkErrorResetF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)

typedef bool(*	MkErrorResetOnExitF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)

typedef void(*	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(*	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(*	MkErrorFormatOfF) (MK_ERREXT_ARGS_N, int const dummy)

typedef void(*	MkErrorSetRF) (MK_ERREXT_ARGS, MK_MNGN const errctx, MK_OBJN const fmtobj)

typedef void(*	MkErrorSetEF) (MK_ERREXT_ARGS, MK_ERREXT const newerr, MK_OBJN const fmtobj)

typedef bool(*	MkErrorSetVLF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj, MK_STRN const)

typedef void(*	MkErrorInit) (MK_ERREXT_ARGS, MK_OBJN const fmtobj)

typedef void(*	MkRuntimeInitF) (MK_RT mkrt)
	additional runtime initialization function …

signed integer data-type
typedef signed char	MK_I8
	1 byte byte data-type

typedef signed short int	MK_I16
	2 byte short data-type

typedef signed int	MK_I32
	4 byte integer data-type

typedef signed long long	MK_I64
	8 byte wide integer data-type

typedef long	MK_LONG
	4/8 byte long data-type

unsigned integer data-type
typedef unsigned char	MK_U8

typedef unsigned short	MK_U16

typedef unsigned int	MK_U32

typedef unsigned long long	MK_U64

typedef unsigned long	MK_ULN

float data-type
typedef float	MK_FLT
	4 byte float data-type

typedef double	MK_DBL
	8 byte double data-type

pointer data-type
typedef void	MK_PTRB
	pointer type data-type

typedef MK_PTRB *	MK_PTR
	generic pointer data-type

typedef const MK_PTRB *	MK_PTRN
	const generic pointer data-type

typedef MK_PTRB *	MK_CCP
	class constructor/destructor data type

typedef MK_PTRB *	MK_CBP
	generic pointer to call-back data

typedef MK_PTRB *	MK_MNG
	managed object pointer, datatype will be checked at runtime

typedef const MK_PTRB *	MK_MNGN
	const - a managed object pointer, datatype will be checked at runtime

typedef MK_PTRB const *	MK_EXP
	exception object pointer

typedef MK_PTRB *	MK_MXP
	MkExceptionC object pointer.

list data-type
typedef unsigned char	MK_LSTB
	list type data-type

typedef MK_LSTB *	MK_LST
	list pointer data-type

binary data-type
typedef unsigned char	MK_BINB
	byte-array type data-type

typedef MK_BINB *	MK_BIN
	byte-array pointer data-type with binary encoding (MK_BINN)

typedef MK_BINB const *	MK_BINN
	const byte-array pointer data-type

helper type for target language implementation
typedef void *	MK_NAT_OBJECT

typedef void *	MK_NAT_LIST

MkObjectC slot definition
typedef MK_OBJ(*	MkConstructorF) (MK_RT mkrt, MK_TYP type, MK_PTR nat, MK_PTR lnk)

typedef void(*	MkDestructorF) (MK_RT mkrt, MK_OBJ const obj)

typedef MK_OBJ(*	MkDupF) (MK_RT mkrt, MK_OBJ const obj)

typedef MK_OBJ(*	MkDup2F) (MK_RT mkrt, MK_OBJ const obj, MK_STRN const ident)

typedef MK_OBJ(*	MkMergeF) (MK_RT mkrt, MK_OBJ const obj)

typedef MK_OBJ(*	MkCopyF) (MK_RT mkrt, MK_OBJ const obj, MK_OBJN const src)

typedef MK_OBJ(*	MkResetF) (MK_RT mkrt, MK_OBJ const obj)

typedef MK_PTR(*	MkSelfCreateF) (MK_RT mkrt, MK_OBJ const obj, MK_PTR const env)

typedef void(*	MkSelfDeleteF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)

typedef void(*	MkSelfUnlinkF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)

typedef void(*	MkLogF) (MK_RT mkrt, MK_OBJN const obj, MK_OBJN fmt, MK_I32 const debug, MK_STRN const prefix, MK_I32 const lvl)

typedef MK_STRN(*	MkToStringF) (MK_RT mkrt, MK_OBJN const obj)

typedef MK_PTR(*	MkAllocCreateFLT) (MK_RT mkrt, MK_TYP const type)

typedef void(*	MkAllocDeleteF) (MK_RT mkrt, MK_TYP const type, MK_PTR ptr)

typedef void(*	MkTypeInitF) (MK_RT mkrt, MK_TYP const type)

typedef bool(*	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	MkIdSE { MK_ID_UNUSED = 0 , MK_ID_PROCESS = 1 , MK_ID_THREAD = 2 }
	signal type of the MkIdS data val … More...

enum	MkSysPipeHandlerE { MK_PIPE_KEEP = 0 , MK_PIPE_IGNORE = 1 }

Functions
static MkBinaryR	MkBinaryCreate (MK_SIZE size, MK_BINN data)
	create a *binary* from *data* and *size* ...

static bool	MkBinaryIsNull (const MkBinaryR bin)
	check if *binary* is NULL ...

static const MkBinaryR	MkBinaryCreateSlice (const MkBinaryR bin, MK_SIZE start, MK_SIZE wide)
	create a *binary* slice ...

static MkBinaryR	MkBinaryDup_RT (MK_RT mkrt, const MkBinaryR bin)
	create a *binary* as duplicate from an already existsing MkBinaryR ...

static void	MkBinaryLog_RT (MK_RT mkrt, const MkBinaryR bin)
	get *size* from the *binary* ...

static MK_BINN	MkBinaryGetData (const MkBinaryR bin)
	get *data* pointer from the *binary* ...

static MK_SIZE	MkBinaryGetSize (const MkBinaryR bin)
	get *size* from the *binary* ...

static void	MkStringLog_RT (MK_RT mkrt, MkStringR const str, MK_STRN func)
	log the *string* ...

static MkStringR	MkStringCreate (MK_NUM len, MK_STRN str)
	create a *str* from *ptr* and *len* ...

static MkStringR	MkStringCreate_1 (MK_STRN str)
	create a *str* from *ptr* use `MK_NULL` as end-of-string ...

static MkStringR	MkStringSlice (MkStringR strR, MK_NUM start, MK_NUM len)
	create a slice of *strR* start at *start* with max *len* bytes …

static void	MkStringSplit (MkStringR strR, MK_NUM len_out, MK_STRN str_out)
	split a *str* into ptr and len …

static MkStringR	MkStringDup_RT (MK_RT mkrt, MkStringR const str)
	create a *string* as duplicate from an already existsing MkBinaryR ...

static MK_STRN	MkStringGetData (MkStringR const str)
	get *ptr* pointer from the *string* ...

static MK_NUM	MkStringGetSize (MkStringR const str)
	get *len* from the *string* ...

static bool	MkStringIsNULL (MkStringR const strR)
	check if *strR* is MK_NULL_STR return `true` or `false` …

MK_STRN	MkIdSE_ToString (enum MkIdSE value)
	return the MkIdSE as string …

static MK_I32	MkIdSE_ToInt (enum MkIdSE value)
	return the MkIdSE as integer …

enum MkErrorE	MkIdSE_FromInt (MK_I32 const value, enum MkIdSE *value_out)
	return the MkIdSE from integer …

void	MkSetup (void)
	setup libmkkernel internal memory …

void	MkCleanup (void)
	cleanup libmkkernel internal memory …

bool	MkHasThread (void)

bool	MkHasFork (void)

MK_PTR	MkSysCalloc (MK_OBJN fmtobj, size_t const nmemb, size_t const size)
	calloc syscall with libmkkernel error plugin

MK_PTR	MkSysMalloc (MK_OBJN fmtobj, size_t const size)
	malloc syscall with libmkkernel error plugin

MK_STR	MkSysStrDup (MK_OBJN fmtobj, MK_STRN const str)
	strdup syscall with libmkkernel error plugin

MK_STR	MkSysStrNDup (MK_OBJN fmtobj, MK_STRN const str, MK_SIZE const len)
	strndup syscall with libmkkernel error plugin

enum MkErrorE	MkSysStrNCpy (MK_OBJN fmtobj, MK_STR const to, MK_STRN const from, MK_SIZE const len)
	strncpy syscall with libmkkernel error plugin

MK_PTR	MkSysRealloc (MK_OBJN fmtobj, MK_PTR const buf, size_t const size)
	realloc syscall with libmkkernel error plugin

MK_PTR	MkSysReCalloc (MK_OBJN fmtobj, MK_PTR const buf, MK_NUM const oldnum, MK_NUM const addnum, size_t const size)
	realloc syscall with libmkkernel error plugin

MK_PTR	MkSysMemDup (MK_OBJN fmtobj, MK_PTRN const blck, size_t const size)
	memdup syscall with libmkkernel error plugin

MK_STRN_A	MkSysStringArrayDup (MK_OBJN fmtobj, MK_STRN_A const strA)
	strdup syscall with libmkkernel error plugin

void	MkSysFree (MK_PTR pointer)
	free syscall …

void	MkSysFreeNonNull (MK_PTR pointer)

void	MkSysFreeP (MK_PTR data)
	free syscall with libmkkernel error plugin

void	MkSysPrintTrace_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_I32 skip, MK_I32 const num, MK_I32 const debug, MK_STRN const callfunc, MK_I32 const lvl)
	backtrace syscall with libmkkernel error plugin

void	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	MkSysGetTrace_RT (MK_RT mkrt, MK_OBJN fmtobj, MK_I32 skip, MK_I32 const num, MK_I32 const debug, MK_STRN const callfunc, MK_I32 const lvl)
	same as MkSysPrintTrace but return an string…

static enum MkErrorE	MkSysWaitForProcess (MK_OBJN fmtobj, MK_IDNT const id)
	wait for process to finish syscall with libmkkernel error plugin

static enum MkErrorE	MkSysWaitForThread (MK_OBJN fmtobj, MK_IDNT const id)
	wait for thread to finish syscall with libmkkernel error plugin

static enum MkErrorE	MkSysUSleep (MK_OBJN fmtobj, useconds_t const usec)
	usleep syscall with libmkkernel error plugin

static enum MkErrorE	MkSysSleep (MK_OBJN fmtobj, MK_I32 const sec)
	sleep syscall with libmkkernel error plugin

static MK_NO_RETURN void	MkSysExit (MK_RT mkrt, int isThread, int num)
	exit syscall with libmkkernel error plugin

MK_STR	MkSysBasename_RT (MK_RT mkrt, MK_STRN const pathName, bool const includeExtension)
	basename syscall with libmkkernel error plugin

MK_STR	MkSysDirname_RT (MK_RT mkrt, MK_STRN const pathName)
	dirname syscall with libmkkernel error plugin

MK_STR	MkSysPrintF_RT (MK_RT mkrt, MK_STRN const format,...)
	sprintf syscall with libmkkernel error plugin

enum MkErrorE	MkSysGetTimeOfDay (MK_OBJN fmtobj, struct mk_timeval tv_out, struct mk_timezone tz_out)
	gettimeofday syscall with libmkkernel error plugin

bool	MkSysStringSetNULL_R (MK_STRN const str)
	set string to EMPTY …

bool	MkSysStringSet_R (MK_STRN const str, MK_STRN const other)
	set string to value …

bool	MkSysStringIsNULL_R (MK_STRN const str)
	test if string EMPTY …

static bool	MkSysStringIsNULL (MK_STRN str)
	test if string is NULL or EMPTY …

static bool	MkSysStringIsNotNULL (MK_STRN str)
	test if string is NOT NULL or EMPTY …

bool	MkSysStringIsEQUAL (MK_STRN const str, MK_STRN const other)
	test if string(s) are equal …

bool	MkSysStringIsLenEQUAL (MK_STRN const str, MK_STRN const other, MK_SIZE const len)
	test if string(s) are equal …

static MK_STRN	MkSysStringGet (MK_STRN str)
	get string NULL or VALUE …

static MK_STRN	MkSysStringGetNoNULL (MK_STRN str)
	get string "" or VALUE …

MK_STRN	MkSysHashSTR (MK_STRN key, MK_NUM length)
	compute the HASH from a string …

MK_I32	MkSysHashI32 (MK_STRN key, MK_NUM length)
	same as MkSysHashSTR but return MK_I32 …

enum MkErrorE	MkSysKill (MK_OBJN fmtobj, MK_I32 pid, MK_I32 signal)
	kill syscall with libmkkernel error plugin

enum MkErrorE	MkSysGetPid (MK_OBJN fmtobj, MK_I32 *pid_out)
	getpid syscall with libmkkernel error plugin

void	MkSysPipeHandler (MkSysPipeHandlerE keepPipe)
	internal support for pipe ignore

static MK_TYP	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	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	MkTypeSlotResolveP (MK_RT mkrt, MK_TYPN const type, size_t const offset, bool const force)
	hidden function for MkTypeSlotResolve

MK_OBJ	MkObjDup_RT (MK_RT mkrt, MK_OBJ const srcobj)
	call the Dup-Constructor from the object

MK_OBJ	MkObjDup2_RT (MK_RT mkrt, MK_OBJ const srcmng, MK_STRN const ident)
	call the Dup2-Constructor from the object

MK_OBJ	MkObjMerge_RT (MK_RT mkrt, MK_OBJ const obj)
	Constructor - create a new object as a merge from an existing object

MK_OBJ	MkObjCreate_RT (MK_RT mkrt, MK_TYP type, MK_PTR nat, MK_PTR lnk)
	call the Constructor from the object

void	MkObjectDelete_RT (MK_RT mkrt, MK_OBJ obj)
	Delete-Slot - delete an instance.

void	MkObjectDispose_RT (MK_RT mkrt, MK_OBJ obj)
	Dispose-Slot - untie the connection between the Native-C-Instance and the libmkkernel-Instance.

enum MkErrorE	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	MkObjectDeleteCallbackCleanup_RT (MK_RT mkrt, MK_STRN ident)
	cleanup the DeleteCallback installed with MkObjectDeleteCallbackSetup …

MK_OBJ	MkObjCopy_RT (MK_RT mkrt, MK_OBJ const tgtmng, MK_OBJN const srcmng)
	call the copy from the object

MK_OBJ	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	MkTypeCreate (MK_MACRO_TYP const clsV, MK_MACRO_TYP const basicV, MK_STRN const identV)
	create a new type …

MK_TYP	MkTypeDup2_RT (MK_RT mkrt, MK_TYPN const typ, MK_STRN const ident)
	duplicate a type-type as duplicate from an existing *type* but with a new name …

MK_OBJ	MkTypeAlloc_RT (MK_RT mkrt, MK_TYPN const typ)
	alloc instance-memory for MkTypeS …

MK_TYP	MkTypeResolve_RT (MK_RT mkrt, MK_TYPN const typ)
	resolve a new type

void	MkTypeDelete_RT (MK_RT mkrt, MK_TYP const typ)
	delete a type object

void	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	MkKernelGetTypeList_RT (MK_RT mkrt)
	return a list of all types defind in the Programming-Language-Micro-Kernel (PLMK) …

MK_STRN const	MkObjectToName_RT (MK_RT mkrt, MK_OBJN const obj)
	Info-Slot - returns brief information about the obj as a string

MK_STRN	MkObjectToNameOfType_RT (MK_RT mkrt, MK_OBJN const obj)
	Type-Slot - returns the LibMkKernel-Type-Name of the obj as a string

MK_STRN	MkObjectToNameOfClass_RT (MK_RT mkrt, MK_OBJ const obj)
	Class-Slot - returns the C-Class-Name of the obj as string

MK_STRN	MkObjectToString_RT (MK_RT mkrt, MK_OBJN const inst)
	String-Slot - returns the string representation of the *inst* …

static bool	MkObjectIsNull (MK_OBJ const obj)
	ckeck if the object is `MK_NULL`

void	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	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	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	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	MkObjectLogSimple_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	MkObjectLogDetail_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	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	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	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	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	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	MkDbgO_RT (MK_RT mkrt, MK_OBJN const obj, MK_STRN const callfunc)
	debug: write the object-details to MkLogFileC (default: stderr) …

void	MkDbgLogC_RT (MK_RT mkrt, MK_OBJN const obj, MK_STRN const callfunc)
	debug: write a short-obj-summary to MkLogFileC (default: stderr) …

enum MkErrorE	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	MkString2I8_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I8 *val_out)

enum MkErrorE	MkString2I16_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I16 *val_out)

enum MkErrorE	MkString2U16_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_U16 *val_out)

enum MkErrorE	MkString2I32_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I32 *val_out)

enum MkErrorE	MkString2U32_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_U32 *val_out)

enum MkErrorE	MkString2I64_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_I64 *val_out)

enum MkErrorE	MkString2FLT_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_FLT *val_out)

enum MkErrorE	MkString2DBL_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_DBL *val_out)

enum MkErrorE	MkString2LONG_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_LONG *val_out)

enum MkErrorE	MkString2BOOL_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_BOOL *val_out)

enum MkErrorE	MkString2ATO_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, enum MkTypeE type, MK_ATO *val_out)

enum MkErrorE	MkString2HDL_RT (MK_RT mkrt, MK_STRN const str, MK_NUM const length, MK_HDL *val_out)

MK_BUF	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	MkBufferCreate64_RT (MK_RT mkrt, MK_NUM const size)
	call the BufferCreate with default type MkBuffer64S (64 byte) …

MK_BUF	MkBufferCreate256_RT (MK_RT mkrt, MK_NUM const size)
	call the BufferCreate with default type MkBuffer256S (256 byte) …

MK_BUF	MkBufferCreate1024_RT (MK_RT mkrt, MK_NUM const size)
	call the BufferCreate with default type MkBuffer1024S (1024 byte) …

void	MkBufferCreateTLS_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size)

void	MkBufferCreateTLS_inout_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_BUF *inout)

void	MkBufferCreateLOCAL_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size)

MK_BUF	MkBufferCreateI8_RT (MK_RT mkrt, MK_I8 const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateBOL_RT (MK_RT mkrt, MK_BOL const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateI16_RT (MK_RT mkrt, MK_I16 const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateI32_RT (MK_RT mkrt, MK_I32 const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateFLT_RT (MK_RT mkrt, MK_FLT const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateI64_RT (MK_RT mkrt, MK_I64 const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateDBL_RT (MK_RT mkrt, MK_DBL const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateSTR_RT (MK_RT mkrt, MK_STRN const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateBIN_RT (MK_RT mkrt, MkBinaryR const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

MK_BUF	MkBufferCreateTLS_RT (MK_RT mkrt, MK_STRN const tlsName, bool const resetB)
	same as BufferCreate but require no cleanup

MK_BUF	MkBufferCreateBUF_RT (MK_RT mkrt, MK_BUFN const val)
	Constructor - create a new MkBufferC with an PRIMITIVE TYPE …

void	MkBufferFree_RT (MK_RT mkrt, MK_BUF const buf)
	initialize or free an MkBufferC reference-instance …

void	MkBufferInit_RT (MK_RT mkrt, MK_BUF const buf, MK_TYP type, MK_NUM const size)
	initialize or free an MkBufferC reference-instance …

void	MkBufferDelete_RT (MK_RT mkrt, MK_BUF const buf)
	Destructor - delete a MkBufferC instance …

MK_BUF	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	MkBufferMerge_RT (MK_RT mkrt, MK_BUF const buf)
	Merge-Constructor - create a new MkBufferC as a merge from an existing object …

enum MkErrorE	MkBufferGetI8_RT (MK_RT mkrt, MK_BUFN const buf, MK_I8 *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetBOL_RT (MK_RT mkrt, MK_BUFN const buf, MK_BOL *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetI16_RT (MK_RT mkrt, MK_BUFN const buf, MK_I16 *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetU16_RT (MK_RT mkrt, MK_BUFN const buf, MK_U16 *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetI32_RT (MK_RT mkrt, MK_BUFN const buf, MK_I32 *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetU32_RT (MK_RT mkrt, MK_BUFN const buf, MK_U32 *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetFLT_RT (MK_RT mkrt, MK_BUFN const buf, MK_FLT *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetI64_RT (MK_RT mkrt, MK_BUFN const buf, MK_I64 *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetDBL_RT (MK_RT mkrt, MK_BUFN const buf, MK_DBL *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetBIN_RT (MK_RT mkrt, MK_BUFN const buf, MkBinaryR *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetSTR_RT (MK_RT mkrt, MK_BUFN const buf, MK_STRN *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetStringR_RT (MK_RT mkrt, MK_BUFN const buf, MkStringR *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetBUF_RT (MK_RT mkrt, MK_BUF const buf, MK_BUF *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	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	MkBufferGetLONG_RT (MK_RT mkrt, MK_BUFN const buf, MK_LONG *const val_out)
	get a *val_out* from a MkBufferC …

enum MkErrorE	MkBufferGetBOOL_RT (MK_RT mkrt, MK_BUFN const buf, MK_BOOL *const val_out)
	get a *val_out* from a MkBufferC …

MK_BUF	MkBufferSetI8_RT (MK_RT mkrt, MK_BUF const buf, MK_I8 const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetBOL_RT (MK_RT mkrt, MK_BUF const buf, MK_BOL const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetI16_RT (MK_RT mkrt, MK_BUF const buf, MK_I16 const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetI32_RT (MK_RT mkrt, MK_BUF const buf, MK_I32 const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetFLT_RT (MK_RT mkrt, MK_BUF const buf, MK_FLT const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetI64_RT (MK_RT mkrt, MK_BUF const buf, MK_I64 const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetDBL_RT (MK_RT mkrt, MK_BUF const buf, MK_DBL const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetSTR_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetBIN_RT (MK_RT mkrt, MK_BUF const buf, MkBinaryR const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetBUF_RT (MK_RT mkrt, MK_BUF const buf, MK_BUFN const val)
	Set the MkBufferC to the *val* …

MK_BUF	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	MkBufferSetV_RT (MK_RT mkrt, MK_BUF const buf, MK_FST const val,...)
	set the MkBufferC using a ... value …

MK_BUF	MkBufferSetBinaryR_RT (MK_RT mkrt, MK_BUF const buf, MkBinaryR const val)
	Set the MkBufferC to the *val* …

MK_BUF	MkBufferSetStringR_RT (MK_RT mkrt, MK_BUF const buf, MkStringR const val)
	Set the MkBufferC to the *val* …

MK_STRB	MkBufferGetType1_RT (MK_RT mkrt, MK_BUFN const buf)
	return the type from a MkBufferC as single character value …

enum MkTypeE	MkBufferGetType2_RT (MK_RT mkrt, MK_BUFN const buf)
	return the MkTypeE from a MkBufferC …

MK_STRN	MkBufferGetType3_RT (MK_RT mkrt, MK_BUFN const buf)
	return the type from a MkBufferC as single character string …

bool	MkBufferIsLocal_RT (MK_RT mkrt, MK_BUFN const buf)
	Check if the MkBufferC is local (temporary), not local mean global …

void	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	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	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	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	MkBufferCastTo_RT (MK_RT mkrt, MK_BUF const buf, enum MkTypeE const typ)
	change the type of an MkBufferC to type …

MK_STRN	MkBufferToString_RT (MK_RT mkrt, MK_BUFN const inst)
	String-Slot - returns the string representation of the *inst* …

MK_BUF	MkBufferSizeNew_RT (MK_RT mkrt, MK_BUF const buf, MK_NUM const size)
	alloc min size storage to the buf …

MK_BUF	MkBufferSizeAdd_RT (MK_RT mkrt, MK_BUF const buf, MK_NUM const size)
	add size storage to the buf …

MK_BUF	MkBufferReset_RT (MK_RT mkrt, MK_BUF const buf)
	reset a MkBufferC to the length zero …

void	MkBufferResetFull_RT (MK_RT mkrt, MK_BUF const buf)
	reset a MkBufferC to the length zero and free allocated storage…

MK_BUF	MkBufferCopy_RT (MK_RT mkrt, MK_BUF const buf, MK_BUFN const srce)
	copy the MkBufferC from srce to dest …

MK_BUF	MkBufferTemp_RT (MK_RT mkrt, MK_BUFN const buf)
	create a temporary copy of the MkBufferC buf …

MK_BUF	MkBufferAppendSTR_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
	append a single string to a MkBufferC object …

MK_BUF	MkBufferAppendStringR_RT (MK_RT mkrt, MK_BUF const buf, MkStringR const val)
	append a single string to a MkBufferC object …

MK_I32	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	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	MkBufferPush_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
	add str to the MkBufferC …

MK_NUM	MkBufferPop_RT (MK_RT mkrt, MK_BUF const buf, MK_STRN const val)
	delete str from the MkBufferC …

enum MkErrorE	MkBufferToObject_RT (MK_RT mkrt, MK_BUF const buf, MK_NAT_OBJECT *obj_out)
	return the native language object from a MkBufferC …

MK_BUS	MkBufferStreamCreate_RT (MK_RT mkrt, MK_TYP type, MK_NUM const size)
	create and initialize an MkBufferStreamC instance …

MK_BUS	MkBufferStreamCreate64_RT (MK_RT mkrt, MK_NUM const size)
	call the BufferStreamCreate with default type MkBufferStream64S (64 byte) …

MK_BUS	MkBufferStreamCreate256_RT (MK_RT mkrt, MK_NUM const size)
	call the BufferStreamCreate with default type MkBufferStream256S (256 byte) …

MK_BUS	MkBufferStreamCreate1024_RT (MK_RT mkrt, MK_NUM const size)
	call the BufferStreamCreate with default type MkBufferStream1024S (1024 byte) …

MK_BUS	MkBufferStreamCreate16384_RT (MK_RT mkrt, MK_NUM const size)
	call the BufferStreamCreate with default type MkBufferStream16384S (16384 byte) …

MK_BUS	MkBufferStreamCreateTLS_RT (MK_RT mkrt, MK_STRN const tlsName, bool const resetB)
	same as BufferStreamCreate but require no cleanup …

void	MkBufferStreamCreateLOCAL_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size)

void	MkBufferStreamCreateSTATIC_T (MK_MACRO_TYP cls, MK_MACRO_TYP name)

void	MkBufferStreamCreateTLS_T (MK_MACRO_TYP cls, MK_MACRO_TYP name)

void	MkBufferStreamFree_RT (MK_RT mkrt, MK_BUS const bus)
	*init* and *free* a MkBufferStreamS reference

void	MkBufferStreamInit_RT (MK_RT mkrt, MK_BUS const bus, MK_TYP type, MK_NUM const size)
	*init* and *free* a MkBufferStreamS reference

void	MkBufferStreamDelete_RT (MK_RT mkrt, MK_BUS const bus)
	Destructor - delete a MkBufferStreamC instance …

MK_BUS	MkBufferStreamMerge_RT (MK_RT mkrt, MK_BUS const bus)
	Merge-Constructor - create a new MkBufferStreamC as a merge from an existing object …

MK_BUS	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	MkBufferStreamCopy_RT (MK_RT mkrt, MK_BUS const bus, MK_BUSN const src)
	copy the MkBufferStreamC from src to bus …

MK_BUS	MkBufferStreamReset_RT (MK_RT mkrt, MK_BUS const bus)
	reset a MkBufferStreamC to the length zero …

void	MkBufferStreamResetFull_RT (MK_RT mkrt, MK_BUS const bus)
	reset a MkBufferStreamC to the length zero and free allocated storage…

void	MkBufferStreamLogS_RT (MK_RT mkrt, MK_BUS const bus, MK_OBJ fmtobj, MK_STRN const callfunc)

void	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	MkBufferStreamPosToStart_RT (MK_RT mkrt, MK_BUS const bus)
	set the current-access-position to the start of MkBufferStreamC …

MK_STRN	MkBufferStreamToString_RT (MK_RT mkrt, MK_BUSN const inst)
	String-Slot - returns the string representation of the *inst* …

MK_BFL	MkBufferStreamToBFL_RT (MK_RT mkrt, MK_BUSN const bus)
	convert the *bus* into a MkBufferListC …

enum MkErrorE	MkBufferStreamWriteI8_RT (MK_RT mkrt, MK_BUS const bus, MK_I8 const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteBOL_RT (MK_RT mkrt, MK_BUS const bus, MK_BOL const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteI32_RT (MK_RT mkrt, MK_BUS const bus, MK_I32 const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteFLT_RT (MK_RT mkrt, MK_BUS const bus, MK_FLT const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteI64_RT (MK_RT mkrt, MK_BUS const bus, MK_I64 const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteDBL_RT (MK_RT mkrt, MK_BUS const bus, MK_DBL const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	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	MkBufferStreamWriteBIN_RT (MK_RT mkrt, MK_BUS const bus, MkBinaryR const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteBUF_RT (MK_RT mkrt, MK_BUS const bus, MK_BUFN const val)
	write a PRIMITIVE TYPE into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteHDL_RT (MK_RT mkrt, MK_BUS const bus, MK_I32 const val)
	write the handle into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteLONG_RT (MK_RT mkrt, MK_BUS const bus, MK_LONG const val)
	write the long native object into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteVL_RT (MK_RT mkrt, MK_BUS const bus, MK_STRN const fmt, va_list ap)
	write format-string into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteV_RT (MK_RT mkrt, MK_BUS const bus, MK_STRN const fmt,...)
	write format-string into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteBFL_RT (MK_RT mkrt, MK_BUS const bus, MK_BFLN const bfl)
	write a MkBufferListC into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteL_FLAT_RT (MK_RT mkrt, MK_BUS const bus, MK_BFL const bfl)
	write a MkBufferListC FLAT into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteL_START_RT (MK_RT mkrt, MK_BUS const bus)
	START write a list-item-type into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteL_END_RT (MK_RT mkrt, MK_BUS const bus)
	END write a list-item-type into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamWriteBUS_FLAT_RT (MK_RT mkrt, MK_BUS const bus, MK_BUSN const add)
	write a MkBufferStreamC into the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadL_START_RT (MK_RT mkrt, MK_BUS const bus, MK_BUF buf)
	START read a list-item-type from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadL_END_RT (MK_RT mkrt, MK_BUS const bus)
	END read a list-item-type from the MkBufferStreamC …

enum MkErrorE	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	MkBufferStreamReadBFL_RT (MK_RT mkrt, MK_BUS const bus, MK_BFL *const val_out)
	read a MkBufferListC from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadLIST_RT (MK_RT mkrt, MK_BUS const bus, MK_NAT_LIST *const val_out)

enum MkErrorE	MkBufferStreamReadNEXT_RT (MK_RT mkrt, MK_BUS const bus, MK_NAT_OBJECT *const val_out)

enum MkErrorE	MkBufferStreamReadLONG_RT (MK_RT mkrt, MK_BUS const bus, MK_LONG *const val_out)
	read the long native object from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadI8_RT (MK_RT mkrt, MK_BUS const bus, MK_I8 *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadBOL_RT (MK_RT mkrt, MK_BUS const bus, MK_BOL *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadI32_RT (MK_RT mkrt, MK_BUS const bus, MK_I32 *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadFLT_RT (MK_RT mkrt, MK_BUS const bus, MK_FLT *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadI64_RT (MK_RT mkrt, MK_BUS const bus, MK_I64 *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadDBL_RT (MK_RT mkrt, MK_BUS const bus, MK_DBL *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadSTR_RT (MK_RT mkrt, MK_BUS const bus, MK_STRN *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadBIN_RT (MK_RT mkrt, MK_BUS const bus, MkBinaryR *const val_out)
	read a *val_out* from the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadBUF_RT (MK_RT mkrt, MK_BUS const bus, MK_BUF *const val_out)
	read a *val_out* from the MkBufferStreamC …

bool	MkBufferStreamReadItemExists_RT (MK_RT mkrt, MK_BUSN const bus)
	check if an item exists in the read-data-package …

enum MkTypeE	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	MkBufferStreamReadGetNumItems_RT (MK_RT mkrt, MK_BUSN const bus)
	get the number of items left in the MkBufferStreamC …

enum MkErrorE	MkBufferStreamReadUndo_RT (MK_RT mkrt, MK_BUS const bus)
	undo the last MkBufferStreamC READ function call …

enum MkErrorE	MkLogFileOpen_RT (MK_RT mkrt, MK_OBJ errfmt, MK_STRN const file, MK_LFL *lfh_out)
	open the log-file in append mode …

void	MkLogFileClose_RT (MK_RT mkrt, MK_LFL lfh)
	Destructor - delete a MkLogFileC instance …

enum MkErrorE	MkLogFileWriteVL_RT (MK_RT mkrt, MK_LFLN lfl, MK_FST printfmt, va_list var_list)
	write to log-file …

enum MkErrorE	MkLogFileWriteV_RT (MK_RT mkrt, MK_LFLN lfl, MK_FST printfmt,...)
	write to log-file …

enum MkErrorE	MkLogFileWriteC_RT (MK_RT mkrt, MK_LFLN lfl, MK_STRN text)
	write to log-file …

enum MkErrorE	MkLogFileGetFile_RT (MK_RT mkrt, MK_LFLN lfl, MK_STRN *file_out)
	get the log-file …

bool	MkExtensionDeleteAll_RT (MK_RT mkrt, MK_EXT head)

MK_EXT	MkExtensionAdd_RT (MK_RT mkrt, MK_EXT head, MK_EXT add)
	this is an update to head, use: `head = MkExtensionAdd(head, add)`

MK_EXT	MkExtensionDel_RT (MK_RT mkrt, MK_EXT head, MK_EXT del)
	this is an update to head, use: `head = MkExtensionDel(head, del)`

void	MkErrorDelete_RT (MK_RT mkrt, MK_ERR err)
	Destructor - delete a MkErrorS object …

MK_ERR	MkErrorDup_RT (MK_RT mkrt, MK_ERRN const srce)
	Dup-Constructor - create a new MkErrorC instance as copy from an existing MkErrorC instance …

enum MkErrorE	MkErrorGetCode (MK_ERRN const err)
	get the value of MkErrorS::code …

MK_STRN	MkErrorGetText (MK_ERRN const err)
	get the MkErrorS::text …

MK_SIZE	MkErrorGetSize (MK_ERRN const err)
	get the error-message-size from the exception-object …

MK_I32	MkErrorGetNum (MK_ERRN const err)
	get the MkErrorS::num. The number can be used as exit-code …

void	MkErrorSetCONTINUE_RT (MK_RT mkrt, MK_ERR const err)
	signal end of processing in an MqMqEventIF callback …

enum MkErrorE	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	MkErrorSetSOCKET_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const detail, MK_STRN const callfunc)
	create SOCKET-DOWN error …

enum MkErrorE	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	MkErrorSetCode_RT (MK_RT mkrt, MK_ERR const err, enum MkErrorE code)
	set the MkErrorS::code value …

bool	MkErrorIsSOCKET (MK_ERRN const err)
	check on SOCKET-DOWN error …

bool	MkErrorIsABORT (MK_ERRN const err)
	check on *ABORT* signal …

bool	MkErrorIsTIMEOUT (MK_ERRN const err)
	check on *TIMEOUT* error …

bool	MkErrorIsEXIT (MK_ERR const err)
	check on APPLICATION-EXIT error …

void	MkPanicVL_RT (MK_RT mkrt, MK_OBJN const errfmt, 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	MkPanicV_RT (MK_RT mkrt, MK_OBJN const errfmt, MK_STRN const callfunc, MK_I32 const errnum, MK_FST const printfmt,...)
	do a panic with a vararg as argument …

void	MkPanicC_RT (MK_RT mkrt, MK_OBJN const errfmt, MK_STRN const callfunc, MK_I32 const errnum, MK_STRN const message)
	do a panic with string as argument …

void	MkDisasterSignal (MK_I32 signal)
	called if something get REALLY wrong …

void	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	MkErrorAppendV_RT (MK_RT mkrt, MK_ERR const err, MK_FST const printfmt,...)
	append a vararg string to the MkErrorC …

void	MkErrorAppendC_RT (MK_RT mkrt, MK_ERR const err, MK_STRN const message)
	append the message to the MkErrorS::text …

MK_ERR	MkErrorNoRaise_RT (MK_RT mkrt, MK_ERR const err)
	ignore the next return of MK_ERROR and do not raise an target-language-exception …

enum MkErrorE	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	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	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	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	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	MkErrorPrintln_RT (MK_RT mkrt, MK_ERR const err)
	print the default-error to the MkLogFileC (default: stderr) and clear the error afterwards …

void	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	MkErrorCatch_RT (MK_RT mkrt, MK_ERR const err, MK_EXP const exception, MK_STRN const callfunc)
	convert a programming-language-error into an libmkkernel error …

MK_ERR	MkObjectErrorCatch_RT (MK_RT mkrt, MK_OBJN const obj, MK_EXP const exception, MK_STRN const callfunc)
	convert a programming-language-error into an libmkkernel error …

enum MkErrorE	MkErrorRaise_RT (MK_RT mkrt, MK_ERRN const err)
	convert an libmkkernel error into an programming-language-error and raise afterwards. …

enum MkErrorE	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 MK_OK …

void	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	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	MkErrorToString_RT (MK_RT mkrt, MK_ERRN const inst)
	String-Slot - returns the string representation of the *inst* …

bool	MkExceptionCheck (MK_EXP exception)
	Checks if *Exception* is of type MkExceptionC and returns `MK_YES` or `MK_NO` …

void	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	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	MkRuntimeSetup (MK_RT const mkrt)
	initialize MkRuntimeRLS …

void	MkRuntimeCleanup (MK_RT mkrt)
	cleanup MkRuntimeRLS …

static MK_RT	MkRuntimeGet (void)
	return a initialized MkRuntimeRLS …

static MK_RT	MkRuntimeGetFromObj (MK_OBJ obj)
	return the initialized MkRuntimeRLS from an *obj* …

static bool	MkRuntimeGetIsSilent (void)
	get the MkRuntimeS::isSilent value …

static void	MkRuntimeSetIsSilent_RT (MK_RT mkrt, bool silent)
	set the MkRuntimeS::isSilent value …

static MK_I32	MkRuntimeGetDebug (void)
	get the MkRuntimeS::debug value …

static void	MkRuntimeSetDebug (MK_I32 dbg)
	set the MkRuntimeS::debug value …

static MK_STRN	MkRuntimeGetLogfile (void)
	get the MkRuntimeS::logfile value …

enum MkErrorE	MkRuntimeSetLogfile_RT (MK_RT mkrt, MK_STRN logfile)
	set the MkRuntimeS::logfile value and cleanup old value …

void	MkRuntimeSetCID (MK_OBJ const cid)
	CID == context-in-duty.

static enum MkErrorE	MkRuntimeGetErrorCode_RT (MK_RT mkrt)
	return MkErrorS::code from a given MkRuntimeC …

void	MkRuntimeLog_RT (MK_RT mkrt, MK_RTN const rt, MK_OBJN fmtobj, MK_DBG const debug, MK_STRN const callfunc, MK_I32 const lvl)
	log the MkRuntimeC …

static MK_OBJ	MkObjectInstancesOfType_RT (MK_RT mkrt, MK_SIG typeSIG)
	return the head-instance from a specific type defined by signature *typeSIG* …

static MK_ERR	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	MkObjectGetNull (void)
	Null-Slot - return a MkObjectC typed `NULL` instance …

MkBufferC - Misc - function - unspecified functions to perform different tasks
static MK_BUF	MkBufferGetNull (void)
	Null-Slot - return a MkBufferC typed `NULL` instance …

MkBufferStreamC - Misc - function - unspecified functions to perform different tasks
static MK_BUS	MkBufferStreamGetNull (void)
	Null-Slot - return a MkBufferStreamC typed `NULL` instance …

MkLogFileC - Misc - function - unspecified functions to perform different tasks
static MK_LFL	MkLogFileGetNull (void)
	Null-Slot - return a MkLogFileC typed `NULL` instance …

MkErrorC - signature check
static bool	MkErrCheck (MK_MNGN mng)
	check MkErrorS -> MkObjectS::signature …

static bool	MkErrCheckO (MK_OBJN obj)
	check MkErrorS -> MkObjectS::signature …

MkErrorC - Misc - function - unspecified functions to perform different tasks
static MK_ERR	MkErrorGetNull (void)
	Null-Slot - return a MkErrorC typed `NULL` instance …

MkRuntimeC - Misc - function - unspecified functions to perform different tasks
static MK_RT	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	MkBufferListInstances_RT (MK_RT mkrt)
	get head-instance from linked-list of MkBufferListS type …

static MK_BFL	MkBufferListNext (MK_BFL const bfl)
	get next instance from linked-list of MkBufferListS type

static MK_BFL	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	MkBufferInstances_RT (MK_RT mkrt)
	get head-instance from linked-list of MkBufferS type …

static MK_BUF	MkBufferNext (MK_BUF const buf)
	get next instance from linked-list of MkBufferS type

static MK_BUF	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	MkBufferStreamInstances_RT (MK_RT mkrt)
	get head-instance from linked-list of MkBufferStreamS type …

static MK_BUS	MkBufferStreamNext (MK_BUS const bus)
	get next instance from linked-list of MkBufferStreamS type

static MK_BUS	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	MkErrorInstances_RT (MK_RT mkrt)
	get head-instance from linked-list of MkErrorS type …

static MK_ERR	MkErrorNext (MK_ERR const err)
	get next instance from linked-list of MkErrorS type

static MK_ERR	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	MkLogFileInstances_RT (MK_RT mkrt)
	get head-instance from linked-list of MkLogFileS type …

static MK_LFL	MkLogFileNext (MK_LFL const lfl)
	get next instance from linked-list of MkLogFileS type

static MK_LFL	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	MkObjectInstances_RT (MK_RT mkrt)
	get head-instance from linked-list of MkObjectS type …

static MK_OBJ	MkObjectNext (MK_OBJ const obj)
	get next instance from linked-list of MkObjectS type

static MK_OBJ	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	MkRuntimeInstances_RT (MK_RT mkrt)
	get head-instance from linked-list of MkRuntimeS type …

static MK_RT	MkRuntimeNext (MK_RT const rt)
	get next instance from linked-list of MkRuntimeS type

static MK_RT	MkRuntimePrev (MK_RT const rt)
	get previous instance from linked-list of MkRuntimeS type

Variables
bool	MkCleanupActive
	signal that code was triggert by MkCleanup

struct MkLalS	MkLal
	Language Abstraction Layer in duty.

__thread struct MkRuntimeS	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 (MK_STRN) is required then the string `"MK_NULL"` is used in C. To support the `NULL` the following items are defined: the NULL-value called MK_NULL the NULL-string called MK_NULL_STR the NULL-string-length called MK_NULL_STR_LEN the NULL-check called 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	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	MK_NULL_STR_CHECK_1 (char const *const __str)
	same as MK_NULL_STR_CHECK but without *len* parameter

static bool	MK_NULL_STR_OR_EMPTY_CHECK_1 (char const *const __str)
	same as MK_NULL_STR_CHECK together with `""` check but without *len* parameter

boolean data-type
#define	bool2str(_bool)

typedef unsigned char	MK_BOL
	1 byte boolean data-type

typedef bool	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: MkObjectHandleGet → The conversion from an instance into a handle. MkObjectHandleResolve → The conversion from an handle into an instance. MkObjectHandleDelete → The handle is deleted. Future use of the same handle will generate an error.
#define	MK_HDL_REF_S3(__prefix)

#define	MK_HDL_REF_S1(__prefix)

#define	MK_HDLT MK_I32T

typedef int32_t	MK_HDL
	4 byte int handle data-type

misc data-type
#define	MK_FORMAT_N "%i"

typedef long	MK_SIZE

typedef union MkBufferAtomU	MK_ATO
	8 byte atom data-type

typedef int32_t	MK_NUM
	array size data-type ('num' items in array …

typedef int	MK_DBG
	debug-level data-type …

typedef unsigned int	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 (3652460*60)
	one year

typedef time_t	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	MkTypeE { MK_I8T = ((1 << MK_TYPE_SHIFT) \| MK_TYPE_IS_1_I8E ) , MK_BOLT = ((2 << MK_TYPE_SHIFT) \| MK_TYPE_IS_1_I8E ) , MK_I16T = ((3 << MK_TYPE_SHIFT) \| MK_TYPE_IS_2_I8E ) , MK_I32T = ((4 << MK_TYPE_SHIFT) \| MK_TYPE_IS_4_I8E ) , MK_FLTT = ((5 << MK_TYPE_SHIFT) \| MK_TYPE_IS_4_I8E ) , MK_I64T = ((6 << MK_TYPE_SHIFT) \| MK_TYPE_IS_8_I8E ) , MK_DBLT = ((7 << MK_TYPE_SHIFT) \| MK_TYPE_IS_8_I8E ) , MK_BINT = ((8 << MK_TYPE_SHIFT) ) , MK_STRT = ((9 << MK_TYPE_SHIFT) ) , MK_LSTT = ((10 << MK_TYPE_SHIFT) ) }
	basic data-types supported by Programming-Language-Micro-Kernel (PLMK) … More...

MK_STRN	MkTypeE_ToString (enum MkTypeE value)
	return the MkTypeE as string …

static MK_I32	MkTypeE_ToInt (enum MkTypeE value)
	return the MkTypeE as integer …

enum MkErrorE	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkObjectCTT )
	*class* as MkSuperTypeS-class-type for `MkObjectC` in the Target-Programming-Language (TPL) …

typedef struct MkObjectS	MkObjectCR
	*instance-struct-reference* same as `struct MkObjectS`, useable in a class-macro as: `class##R` …

typedef const struct MkObjectS	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	MkObjCheck (MK_MNGN mng)
	check MkObjectS -> MkObjectS::signature …

static bool	MkObjCheckO (MK_OBJN obj)
	check MkObjectS -> 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	MkObj (MK_MNG mng)
	cast a unknown-object into an MkObjectS pointer or NULL if not possible

static MK_OBJN	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	MkObjectHandleGetOfType (MK_OBJ const obj)
	Export-Slot - returns *typeHdl* of the *obj* .

bool	MkObjectHandleExists (MK_OBJ const obj)
	check if *obj* has already a handle defined…

MK_HDL	MkObjectHandleGetOr0 (MK_OBJ const obj)
	return *export-hdl* or 0 in not created…

MK_HDL	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	MkObjectHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
	Handle-Resolve-Slot - return a MkObjectC from *netHdl* or `MK_NULL` if invalid…

void	MkObjectHandleDeleteByNetHdl_RT (MK_RT mkrt, MK_HDL const netHdl)
	Handle-Delete-Slot - delete a *netHdl* from handle-storage …

void	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	MkTypeCR
	*instance-struct-reference* same as `struct MkTypeS`, useable in a class-macro as: `class##R` …

typedef const struct MkTypeS	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	MkTypCheck (MK_MNGN mng)
	check MkTypeS -> MkObjectS::signature …

static bool	MkTypCheckO (MK_OBJN obj)
	check MkTypeS -> MkObjectS::signature …

MkSuperTypeC - type definition
#define	MkSuperTypeSTT (&MK_RT_REF._MkSuperTypeC_TT)
	*instance-type* as MkTypeS-class-type

#define	MkSuperTypeC_TT (&MK_RT_REF._MkSuperTypeC_TT)
	*class* as MkTypeS-class-type, useable in a class-macro as: `class##_TT` …

#define	MkSuperTypeCT_X(instance)
	cast from an instance into the MkTypeS-class-type …

#define	MkSuperTypeCTT_X(instance)
	cast from an instance into the MkTypeS-class-type …

#define	MkSuperTypeCT_TT(typ)
	cast from an MkTypeS-class-type into an MkTypeS-class-type …

#define	MkSuperTypeC_NS MK
	map class to namespace …

#define	MkSuperTypeCTT MkSuperTypeCTT
	*class* as MkTypeS-class-type for `MkSuperTypeC` in the Target-Programming-Language (TPL) …

#define	MkSuperTypeCT ( (struct MkTypeS *) MkSuperTypeCTT )
	*class* as MkTypeS-class-type for `MkSuperTypeC` in the Target-Programming-Language (TPL) …

typedef struct MkSuperTypeS	MkSuperTypeCR
	*instance-struct-reference* same as `struct MkSuperTypeS`, useable in a class-macro as: `class##R` …

typedef const struct MkSuperTypeS	MkSuperTypeCNR
	const *instance-struct-reference* same as `const struct MkSuperTypeS`, 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	MkRefIncr (MK_OBJ obj)
	increment the reference-count

void	MkRefDecr_RT (MK_RT mkrt, MK_OBJ obj)
	decrement the reference-count

static void	MkRefIncrSelf (MK_OBJ const obj, MK_PTR const self, MK_PTR const env)
	ATOMIC operation -> link self with reference-count.

MK_OBJ	MkRefDecrWithoutSelf_RT (MK_RT mkrt, MK_OBJ const obj)
	ATOMIC operation -> unlink self with reference-count.

MK_OBJ	MkRefDecrWithUnlinkSelf_RT (MK_RT mkrt, MK_OBJ const obj)
	ATOMIC operation -> unlink self from META und decr-ref-count in MQ.

static MK_I32	MkRefGet (MK_OBJ const obj)
	get the reference-count

static MK_I32	MkRefLock (MK_OBJ const obj)
	lock the object

static bool	MkRefIsLocked (MK_OBJ const obj)
	check if object is locked

MK_NUM	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(*	MkSelfIncrF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)

typedef void(*	MkSelfDecrF) (MK_RT mkrt, MK_PTR self, MK_PTR const env)

static void	MkSelfSet (MK_OBJ const obj, MK_PTR const self, MK_PTR const env)
	set the MkObjectS::self value

static MK_PTR	MkSelfGet (MK_OBJ const obj)
	get the MkObjectS::self value

static MK_ATTR_HOT enum MkErrorE	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	MkSelfCreate_RT (MK_RT mkrt, MK_OBJ const obj, MK_PTR const env)
	create the MkObjectS::self value

bool	MkSelfDelete_RT (MK_RT mkrt, MK_OBJ const obj)
	delete the MkObjectS::self value

bool	MkSelfDeleteForce_RT (MK_RT mkrt, MK_OBJ obj)
	force delete an instance, last step in instance-destructor

void	MkSelfUnlink_RT (MK_RT mkrt, MK_OBJ obj)
	Run the MkTypeS::selfUnlink slot from the instance...

static bool	MkSelfExists (MK_OBJN obj)
	Check if the MkObjectS::self exists …

MkBufferC - type definition
#define	MkBufferC_T (&MK_RT_REF._MkBufferC_T)
	*class* as MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBufferCTT )
	*class* as MkSuperTypeS-class-type for `MkBufferC` in the Target-Programming-Language (TPL) …

typedef struct MkBufferS	MkBufferCR
	*instance-struct-reference* same as `struct MkBufferS`, useable in a class-macro as: `class##R` …

typedef const struct MkBufferS	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	MkBufCheck (MK_MNGN mng)
	check MkBufferS -> MkObjectS::signature …

static bool	MkBufCheckO (MK_OBJN obj)
	check MkBufferS -> 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	MkBuf (MK_MNG mng)
	cast a unknown-object into an MkBufferS pointer or NULL if not possible

static MK_BUFN	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	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	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBuffer64CTT )
	*class* as MkSuperTypeS-class-type for `MkBuffer64C` in the Target-Programming-Language (TPL) …

typedef struct MkBuffer64S	MkBuffer64CR
	*instance-struct-reference* same as `struct MkBuffer64S`, useable in a class-macro as: `class##R` …

typedef const struct MkBuffer64S	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBuffer256CTT )
	*class* as MkSuperTypeS-class-type for `MkBuffer256C` in the Target-Programming-Language (TPL) …

typedef struct MkBuffer256S	MkBuffer256CR
	*instance-struct-reference* same as `struct MkBuffer256S`, useable in a class-macro as: `class##R` …

typedef const struct MkBuffer256S	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBuffer1024CTT )
	*class* as MkSuperTypeS-class-type for `MkBuffer1024C` in the Target-Programming-Language (TPL) …

typedef struct MkBuffer1024S	MkBuffer1024CR
	*instance-struct-reference* same as `struct MkBuffer1024S`, useable in a class-macro as: `class##R` …

typedef const struct MkBuffer1024S	MkBuffer1024CNR
	const *instance-struct-reference* same as `const struct MkBuffer1024S`, useable in a class-macro as: `class##R` …

MkBufferStreamC - type definition
#define	MkBufferStreamC_T (&MK_RT_REF._MkBufferStreamC_T)
	*class* as MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBufferStreamCTT )
	*class* as MkSuperTypeS-class-type for `MkBufferStreamC` in the Target-Programming-Language (TPL) …

typedef struct MkBufferStreamS	MkBufferStreamCR
	*instance-struct-reference* same as `struct MkBufferStreamS`, useable in a class-macro as: `class##R` …

typedef const struct MkBufferStreamS	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	MkBusCheck (MK_MNGN mng)
	check MkBufferStreamS -> MkObjectS::signature …

static bool	MkBusCheckO (MK_OBJN obj)
	check MkBufferStreamS -> 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	MkBus (MK_MNG mng)
	cast a unknown-object into an MkBufferStreamS pointer or NULL if not possible

static MK_BUSN	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	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	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBufferStream64CTT )
	*class* as MkSuperTypeS-class-type for `MkBufferStream64C` in the Target-Programming-Language (TPL) …

typedef struct MkBufferStream64S	MkBufferStream64CR
	*instance-struct-reference* same as `struct MkBufferStream64S`, useable in a class-macro as: `class##R` …

typedef const struct MkBufferStream64S	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBufferStream256CTT )
	*class* as MkSuperTypeS-class-type for `MkBufferStream256C` in the Target-Programming-Language (TPL) …

typedef struct MkBufferStream256S	MkBufferStream256CR
	*instance-struct-reference* same as `struct MkBufferStream256S`, useable in a class-macro as: `class##R` …

typedef const struct MkBufferStream256S	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBufferStream1024CTT )
	*class* as MkSuperTypeS-class-type for `MkBufferStream1024C` in the Target-Programming-Language (TPL) …

typedef struct MkBufferStream1024S	MkBufferStream1024CR
	*instance-struct-reference* same as `struct MkBufferStream1024S`, useable in a class-macro as: `class##R` …

typedef const struct MkBufferStream1024S	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkBufferStream16384CTT )
	*class* as MkSuperTypeS-class-type for `MkBufferStream16384C` in the Target-Programming-Language (TPL) …

typedef struct MkBufferStream16384S	MkBufferStream16384CR
	*instance-struct-reference* same as `struct MkBufferStream16384S`, useable in a class-macro as: `class##R` …

typedef const struct MkBufferStream16384S	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkLogFileCTT )
	*class* as MkSuperTypeS-class-type for `MkLogFileC` in the Target-Programming-Language (TPL) …

typedef struct MkLogFileS	MkLogFileCR
	*instance-struct-reference* same as `struct MkLogFileS`, useable in a class-macro as: `class##R` …

typedef const struct MkLogFileS	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	MkLflCheck (MK_MNGN mng)
	check MkLogFileS -> MkObjectS::signature …

static bool	MkLflCheckO (MK_OBJN obj)
	check MkLogFileS -> 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	MkLfl (MK_MNG mng)
	cast a unknown-object into an MkLogFileS pointer or NULL if not possible

static MK_LFLN	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	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	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkExtensionCTT )
	*class* as MkSuperTypeS-class-type for `MkExtensionC` in the Target-Programming-Language (TPL) …

typedef struct MkExtensionS	MkExtensionCR
	*instance-struct-reference* same as `struct MkExtensionS`, useable in a class-macro as: `class##R` …

typedef const struct MkExtensionS	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	MkExtCheck (MK_MNGN mng)
	check MkExtensionS -> MkObjectS::signature …

static bool	MkExtCheckO (MK_OBJN obj)
	check MkExtensionS -> 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	MkExt (MK_MNG mng)
	cast a unknown-object into an MkExtensionS pointer or NULL if not possible

static MK_EXTN	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkErrorCTT )
	*class* as MkSuperTypeS-class-type for `MkErrorC` in the Target-Programming-Language (TPL) …

typedef struct MkErrorS	MkErrorCR
	*instance-struct-reference* same as `struct MkErrorS`, useable in a class-macro as: `class##R` …

typedef const struct MkErrorS	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	MkErr (MK_MNG mng)
	cast a unknown-object into an MkErrorS pointer or NULL if not possible

static MK_ERRN	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	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	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkErrExtCTT )
	*class* as MkSuperTypeS-class-type for `MkErrExtC` in the Target-Programming-Language (TPL) …

typedef struct MkErrExtS	MkErrExtCR
	*instance-struct-reference* same as `struct MkErrExtS`, useable in a class-macro as: `class##R` …

typedef const struct MkErrExtS	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	MkErrExtCheck (MK_MNGN mng)
	check MkErrExtS -> MkObjectS::signature …

static bool	MkErrExtCheckO (MK_OBJN obj)
	check MkErrExtS -> 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	MkErrExt (MK_MNG mng)
	cast a unknown-object into an MkErrExtS pointer or NULL if not possible

static MK_ERREXTN	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkErrorPanicCTT )
	*class* as MkSuperTypeS-class-type for `MkErrorPanicC` in the Target-Programming-Language (TPL) …

typedef struct MkErrorPanicS	MkErrorPanicCR
	*instance-struct-reference* same as `struct MkErrorPanicS`, useable in a class-macro as: `class##R` …

typedef const struct MkErrorPanicS	MkErrorPanicCNR
	const *instance-struct-reference* same as `const struct MkErrorPanicS`, useable in a class-macro as: `class##R` …

MkErrorIgnoreC - type definition
#define	MkErrorIgnoreC_T (&MK_RT_REF._MkErrorIgnoreC_T)
	*class* as MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkErrorIgnoreCTT )
	*class* as MkSuperTypeS-class-type for `MkErrorIgnoreC` in the Target-Programming-Language (TPL) …

typedef struct MkErrorIgnoreS	MkErrorIgnoreCR
	*instance-struct-reference* same as `struct MkErrorIgnoreS`, useable in a class-macro as: `class##R` …

typedef const struct MkErrorIgnoreS	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkErrorPrintCTT )
	*class* as MkSuperTypeS-class-type for `MkErrorPrintC` in the Target-Programming-Language (TPL) …

typedef struct MkErrorPrintS	MkErrorPrintCR
	*instance-struct-reference* same as `struct MkErrorPrintS`, useable in a class-macro as: `class##R` …

typedef const struct MkErrorPrintS	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkErrorDefaultCTT )
	*class* as MkSuperTypeS-class-type for `MkErrorDefaultC` in the Target-Programming-Language (TPL) …

typedef struct MkErrorDefaultS	MkErrorDefaultCR
	*instance-struct-reference* same as `struct MkErrorDefaultS`, useable in a class-macro as: `class##R` …

typedef const struct MkErrorDefaultS	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
#define	MK_ERROR_DEFAULT_R(r)
	return as MK_OBJ, to return 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	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
#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	MkErrorPANIC_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
#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	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
#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	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] fmtobj managed 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

#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 MkErrorFORMAT (MK_OBJN fmtobj)

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

MK_ERR MkErrorFORMAT_EO (MK_OBJN fmtobj)

same as (static,runtime) MK_ERR MkErrorDEFAULT() 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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkRtExtCTT )
	*class* as MkSuperTypeS-class-type for `MkRtExtC` in the Target-Programming-Language (TPL) …

typedef struct MkRtExtS	MkRtExtCR
	*instance-struct-reference* same as `struct MkRtExtS`, useable in a class-macro as: `class##R` …

typedef const struct MkRtExtS	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	MkRtExtCheck (MK_MNGN mng)
	check MkRtExtS -> MkObjectS::signature …

static bool	MkRtExtCheckO (MK_OBJN obj)
	check MkRtExtS -> 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	MkRtExt (MK_MNG mng)
	cast a unknown-object into an MkRtExtS pointer or NULL if not possible

static MK_RTEXTN	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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS-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 MkSuperTypeS *) MkRuntimeCTT )
	*class* as MkSuperTypeS-class-type for `MkRuntimeC` in the Target-Programming-Language (TPL) …

typedef struct MkRuntimeS	MkRuntimeCR
	*instance-struct-reference* same as `struct MkRuntimeS`, useable in a class-macro as: `class##R` …

typedef const struct MkRuntimeS	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	MkRtCheck (MK_MNGN mng)
	check MkRuntimeS -> MkObjectS::signature …

static bool	MkRtCheckO (MK_OBJN obj)
	check MkRuntimeS -> 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	MkRt (MK_MNG mng)
	cast a unknown-object into an MkRuntimeS pointer or NULL if not possible

static MK_RTN	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	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	MkRuntimeHandleResolve_RT (MK_RT mkrt, MK_HDL const netHdl)
	Handle-Resolve-Slot - return a MkRuntimeC from *netHdl* or `MK_NULL` if invalid…

MkErrorE
enum	MkErrorE { MK_OK = 0 , MK_CONTINUE = 1 , MK_ERROR = 2 }
	collection for the different error-codes … More...

MK_STRN	MkErrorE_ToString (enum MkErrorE value)
	return the MkErrorE as string …

static MK_I32	MkErrorE_ToInt (enum MkErrorE value)
	return the MkErrorE as integer …

enum MkErrorE	MkErrorE_FromInt (MK_I32 const value, enum MkErrorE *value_out)
	return the MkErrorE from integer …

MkTimeoutE
enum	MkTimeoutE { MK_TIMEOUT_INIT = META_TIMEOUT_REF , MK_TIMEOUT_LONG = (META_TIMEOUT_REF/5) , MK_TIMEOUT_NORMAL = (META_TIMEOUT_REF/10 < 1 ? 1 : META_TIMEOUT_REF/10) , MK_TIMEOUT_SHORT = (META_TIMEOUT_REF/45 < 1 ? 1 : META_TIMEOUT_REF/45) , MK_TIMEOUT_SOCKET = (META_TIMEOUT_REF/90 < 1 ? 1 : META_TIMEOUT_REF/90) , MK_TIMEOUT_VERYSHORT = (META_TIMEOUT_REF/180 < 1 ? 1 : META_TIMEOUT_REF/180) , MK_TIMEOUT_DEFAULT = -1 , MK_TIMEOUT_USER = -2 , MK_TIMEOUT_MAX = -3 }
	Predefined Timeout values … More...

MK_STRN	MkTimeoutE_ToString (enum MkTimeoutE value)
	return the MkTimeoutE as string …

static MK_I32	MkTimeoutE_ToInt (enum MkTimeoutE value)
	return the MkTimeoutE as integer …

enum MkErrorE	MkTimeoutE_FromInt (MK_I32 const value, enum MkTimeoutE *value_out)
	return the MkTimeoutE from integer …

MkBoolE
enum	MkBoolE { MK_NO = 0 , MK_YES = 1 }
	the internal boolean … More...

MK_STRN	MkBoolE_ToString (enum MkBoolE value)
	return the MkBoolE as string …

static MK_I32	MkBoolE_ToInt (enum MkBoolE value)
	return the MkBoolE as integer …

enum MkErrorE	MkBoolE_FromInt (MK_I32 const value, enum MkBoolE *value_out)
	return the MkBoolE from integer …

MkNativeIsE
enum	MkNativeIsE { MK_NATIVE_IS_INITIAL = 0 , MK_NATIVE_IS_STRING = 'S' , MK_NATIVE_IS_LITTLE = 'L' , MK_NATIVE_IS_BIG = 'B' }
	define if data is string or little or big endian … More...

MK_STRN	MkNativeIsE_ToString (enum MkNativeIsE value)
	return the MkNativeIsE as string …

static MK_I32	MkNativeIsE_ToInt (enum MkNativeIsE value)
	return the MkNativeIsE as integer …

enum MkErrorE	MkNativeIsE_FromInt (MK_I32 const value, enum MkNativeIsE *value_out)
	return the MkNativeIsE from integer …

primitive string data-type
typedef char	MK_STRB
	string type data-type

typedef MK_STRB *	MK_STR
	string pointer data-type with `UTF8` ecoding (MK_STR)

typedef const MK_STRB *	MK_STRN
	constant string pointer data-type

typedef MK_STRB const *	MK_FST
	const format string pointer data-type

MK_UNUSED static const MK_STRN_A	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: Add a MkRuntimeRLS-callback that is called whenever a new MkRuntimeRLS is created. (simply) Adding a MkRuntimeRLS extension that creates an additional MkRuntimeRLS parallel to the initial MkRuntimeRLS (complicated). 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 ); ... } MkRuntimeCallbackAdd size_t MkRuntimeCallbackAdd(MK_RT mkrt, MkRuntimeCallbackS cbdata, MkRuntimeInitF rt_callback, MK_STRN ident) add a callback to the runtime … MkThreadLocal #define MkThreadLocal Definition LibMkKernel_mk.h:808 MK_RT_CALL_ONLY #define MK_RT_CALL_ONLY Definition LibMkKernel_mk.h:812 MkTypeCreate #define MkTypeCreate(clsV, basicV, identV) Definition LibMkKernel_mk.h:4833 MkRuntimeCallbackS keep callback related data … Definition LibMkKernel_mk.h:12039 MkRuntimeCallbackS::cb MkRuntimeInitF cb required data Definition LibMkKernel_mk.h:12040 MkRuntimeS The MkRuntimeS provide a per-thread environment for libmkkernel … Definition LibMkKernel_mk.h:11550 MkTypeS MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type... Definition LibMkKernel_mk.h:3748
typedef struct MkRuntimeCallbackS	MkRuntimeCallbackS
	keep callback related data …

size_t	MkRuntimeCallbackAdd (MK_RT mkrt, MkRuntimeCallbackS *cbdata, MkRuntimeInitF rt_callback, MK_STRN ident)
	add a callback to the runtime …

void	MkRuntimeCallbackDel (MkRuntimeCallbackS *cbdata)
	delete a callback from the runtime …

Detailed Description

Copyright: (C) NHI - #1 - Project - Group This software has NO permission to copy, please contact AUTHOR for additional information

Version

Date

Author

Definition in file LibMkKernel_mk.h.

Macro Definition Documentation

◆ check_MkErrorE

#define check_MkErrorE ( PROC )

Value:

if (MkErrorCheckI(PROC))

MkErrorCheckI

#define MkErrorCheckI(err)

Definition LibMkKernel_mk.h:10663

check MkErrorE macro …

Definition at line 10714 of file LibMkKernel_mk.h.

◆ META_HDL_USENONNULLGCC_ATTRIBUTE

#define META_HDL_USE__NONNULL__GCC_ATTRIBUTE 0

Definition at line 218 of file LibMkKernel_mk.h.

◆ META_TIMEOUT_REF

#define META_TIMEOUT_REF 900

Definition at line 211 of file LibMkKernel_mk.h.

◆ META_TYPE_DEBUG

#define META_TYPE_DEBUG 0

Definition at line 314 of file LibMkKernel_mk.h.

◆ META_TYPE_DEBUG__printV

#define META_TYPE_DEBUG__printV ( ... )

Definition at line 321 of file LibMkKernel_mk.h.

◆ META_USE_SELF_REFCOUNT

#define META_USE_SELF_REFCOUNT

Definition at line 331 of file LibMkKernel_mk.h.

◆ MkCacheItemS_signature

#define MkCacheItemS_signature 0x44196912

Definition at line 2226 of file LibMkKernel_mk.h.

◆ MkCacheS_MkCacheItemS_size

#define MkCacheS_MkCacheItemS_size 8

Definition at line 2254 of file LibMkKernel_mk.h.

◆ MkCacheS_name_size

#define MkCacheS_name_size 32

Definition at line 2244 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 10681 of file LibMkKernel_mk.h.

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

◆ MkErrorBreak

#define MkErrorBreak ( err )

Value:

if (MkErrorCheckI(err)) break

check return-code and break on error …

Definition at line 10679 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 10673 of file LibMkKernel_mk.h.

◆ MkErrorCheck_0E

#define MkErrorCheck_0E ( )

Value:

if (MkErrorCheckE_0E()) goto error

MkErrorCheckE_0E

#define MkErrorCheckE_0E()

Definition LibMkKernel_mk.h:10667

check return-code and goto error on error …

Definition at line 10677 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_0E

#define MkErrorCheckE_0E ( )

Value:

(MkErrorCheckI(MkErrorGetCode_0E()))

MkErrorGetCode_0E

#define MkErrorGetCode_0E()

Definition kernel_overload_mk.h:984

Definition at line 10667 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_NULL

#define MkErrorCheckE_NULL ( )

Value:

(MkErrorCheckI(MkErrorGetCodeE_NULL()))

MkErrorGetCodeE_NULL

#define MkErrorGetCodeE_NULL()

get the value of MkErrorS::code …

Definition LibMkKernel_mk.h:10490

Definition at line 10668 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_O

#define MkErrorCheckE_O ( o )

Value:

(MkErrorCheckI(MkErrorGetCode_O(o)))

MkErrorGetCode_O

#define MkErrorGetCode_O(o)

get the value of MkErrorS::code …

Definition LibMkKernel_mk.h:10492

Definition at line 10669 of file LibMkKernel_mk.h.

◆ MkErrorCheckE_X

#define MkErrorCheckE_X ( x )

Value:

MkErrorCheckE_O(MkOBJ(x))

MkErrorCheckE_O

#define MkErrorCheckE_O(o)

Definition LibMkKernel_mk.h:10669

MkOBJ

#define MkOBJ(x)

cast a known-object into an MkObjectS pointer

Definition LibMkKernel_mk.h:3391

Definition at line 10670 of file LibMkKernel_mk.h.

◆ MkErrorCheckI

#define MkErrorCheckI ( err )

Value:

((err) >= MK_ERROR)

Returns: 0(no) on MK_OK and MK_CONTINUE and an 1(yes) MK_ERROR

Definition at line 10663 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 10675 of file LibMkKernel_mk.h.

◆ MkErrorReturn

#define MkErrorReturn ( PROC )

Value:

MkErrorReturn_2X(META_CONTEXT_S,PROC)

MkErrorReturn_2X

#define MkErrorReturn_2X(mngx, PROC)

process error message …

Definition LibMkKernel_mk.h:10704

process error message …

Definition at line 10712 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 10708 of file LibMkKernel_mk.h.

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

◆ 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);\
};

process error message …

Definition at line 10704 of file LibMkKernel_mk.h.

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

◆ MkErrorReturnLabel

#define MkErrorReturnLabel ( mng )

Value:

  return MK_OK; \
error: \
  return MkErrorStack_1M(mng);

default return from function with error-label set …

Definition at line 10717 of file LibMkKernel_mk.h.

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

◆ 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 10686 of file LibMkKernel_mk.h.

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

◆ MkRuntimeCallbackS_ident_size

#define MkRuntimeCallbackS_ident_size 30

Definition at line 12042 of file LibMkKernel_mk.h.

◆ MkTypeS_name_size

#define MkTypeS_name_size 32

Definition at line 3758 of file LibMkKernel_mk.h.

Function Documentation

◆ MkObjectInstancesOfType_RT()

static MK_OBJ MkObjectInstancesOfType_RT	(	MK_RT	mkrt,
		MK_SIG	typeSIG )

inlinestatic

return the head-instance from a specific type defined by signature typeSIG …

Definition at line 12896 of file LibMkKernel_mk.h.

                                                                           {
  // TODO replace loop by hash
  MkTypeLoop(MkTypeC,typ) {
    if ((*typ).objsig == typeSIG) return (*typ).instances;
  }
  return NULL;
}

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

MK_NULL

define the NULL

class-instance as NULL

boolean data-type

"handle" data-type

misc data-type

OS wide MK_TIME_T

MkTypeE

MkObjectC - type definition

MkObjectC - signature check

MkObjectC - cast from a defined or a undefined instance

MkObjectC - Export - inline - interact with an external software

MkTypeC - type definition

MkTypeC - signature check

MkSuperTypeC - type definition

MkRef…

MkSelf

MkBufferC - type definition

MkBufferC - signature check

MkBufferC - cast from a defined or a undefined instance

MkBufferC - Export - inline - interact with an external software

MkBuffer64C - type definition

MkBuffer256C - type definition

MkBuffer1024C - type definition

MkBufferStreamC - type definition

MkBufferStreamC - signature check

MkBufferStreamC - cast from a defined or a undefined instance

MkBufferStreamC - Export - inline - interact with an external software

MkBufferStream64C - type definition

MkBufferStream256C - type definition

MkBufferStream1024C - type definition

MkBufferStream16384C - type definition

MkLogFileC - type definition

MkLogFileC - signature check

MkLogFileC - cast from a defined or a undefined instance

MkLogFileC - Export - inline - interact with an external software

MkExtensionC - type definition

MkExtensionC - signature check

MkExtensionC - cast from a defined or a undefined instance

MkErrorC - type definition

MkErrorC - cast from a defined or a undefined instance

MkErrorC - Export - inline - interact with an external software

MkErrExtC - type definition

MkErrExtC - signature check

MkErrExtC - cast from a defined or a undefined instance

MkErrorPanicC - type definition

MkErrorIgnoreC - type definition

MkErrorPrintC - type definition

MkErrorDefaultC - type definition

MkErrorDEFAULT

MkErrorPanik

MkErrorPANIC - usage

MkErrorIgnore

MkErrorIGNORE - usage

MkErrorPrintln

MkErrorPRINT - usage

MkErrorFORMAT

MkErrorFORMAT - usage

MkRtExtC - type definition

MkRtExtC - signature check

MkRtExtC - cast from a defined or a undefined instance

MkRuntimeC - type definition

MkRuntimeC - signature check

MkRuntimeC - cast from a defined or a undefined instance

MkRuntimeC - Export - inline - interact with an external software

MkErrorE

MkTimeoutE

MkBoolE

MkNativeIsE

primitive string data-type

MkRuntimeCallback

Detailed Description

Macro Definition Documentation

◆ check_MkErrorE

◆ META_HDL_USENONNULLGCC_ATTRIBUTE