LibMkKernel_mk.h

Go to the documentation of this file.

 
/* LABEL-NO */
 
#ifndef KERNEL_MK_H
#define KERNEL_MK_H
 
# ifndef PARSE_C_HEADER_TO_META
#   include "debug_mk.h"
# endif
 
// MARK_D ################################################################
// -----------------------------------------------------------------------
// documentation order
 
 
 
 
 
 
 
 
 
 
// =========================================================================================
// Config:      configure definitions
 
// define:      META_HAS_THREAD
// source:      msgque_config.h - set with the "configure" script
// default:     depend on how the LNG and libmqmsgque was compiled
// definition:  1. if defined the T)hread L)ocal S)torage is used.
//              2. the "runtime" command-line-artgumen "mkrt" as FIRST parameter is set
//              3. if "libmqmsgque" was compiled with META_HAS_THREAD this have to be set as well.
 
#ifndef META_HAS_THREAD
  #error "META_HAS_THREAD was NOT defined, require 1 or 0, forget to include 'theKernel/c/compiler.mk' ?"
#endif
 
// =========================================================================================
// Makefile:    CPPFLAGS definitions
 
// define:      META_IGNORE_EXTERN
// source:      Makefile
// default:     not set
// definition:  If the source-code is direct used in an external library (example: C++)
//              (without dynamic linking) and this library should *not* export
//              the symbol's of libmsgque then the flag META_IGNORE_EXTERN have
//              to be set
 
// define:      META_COMPILE_AS_CC
// source:      Makefile, CPPFLAGS=-DMETA_COMPILE_AS_CC
// target:      "C" main header file like 'kernel_mk.h'
// default:     only set by "ccmqmsgque" to compile "C" code as "C++" code with "namespace" support
// definition:  The preprocessor flag "META_COMPILE_AS_CC" is ONLY used together with the C++ compiler. 
//              If the "META_COMPILE_AS_CC" flag is set, the C-code is not compiled into an independent library, 
//              but translated directly into the C++ library together with the additional C++ code as C++ code in 
//              the "libmkkernel" namespace. The difference is that the C code is additionally validated as "C++" 
//              syntax and supports the C++ calling convention. Without "META_COMPILE_AS_CC" the C code is 
//              compiled with "extern C" in the C++ compiler.
//
//              The following changes are done:
//                1. libmkkernel -> compile the code into "namespace libmkkernel"
//                2. libmqmsgque -> compile the code into "namespace libmqmsgque"
//                3. liblcconfig -> compile the code into "namespace liblcconfig"
 
// =========================================================================================
// Header:      build control
 
// define:      MK_C_BUILD_DLL
// source:      Makefile
// target:      api-header and kernel_mk.h
// default:     set at build of the 'libmkkernel' library but NOT set for other libraries
// definition:  this define has two porpose:
//              1. set the MK_EXTERN and MK_EXTERN_DATA to export of definition
//              2. use the private definition of partly public struct's
 
// =========================================================================================
// Header:      api definition
 
// define:      META_TIMEOUT_REF
// source:      api-header or Makefile
// default:     900sec
// definition:  base timeout value - all other timeout will be calulated relative to this timeout
 
#define META_TIMEOUT_REF 900   //< reference value for timeout… default: 15 min
 
// define:      META_HDL_USE__NONNULL__GCC_ATTRIBUTE
// source:      api-header or Makefile
// target:      api-header, check_mk.h
// default:     do NOT use "nonnull" attribute
 
#define META_HDL_USE__NONNULL__GCC_ATTRIBUTE 0
 
// define:      META_ATTRIBUTE_SANITIZE
// source:      api-header or Makefile
// target:      msgque_mq.h
// default:     __attribute__((no_sanitize("address")))
// definition:  The C2GO compiler does NOT understand the 'no_sanitize("address")' attribute
//              -> use "-DMETA_ATTRIBUTE_SANITIZE=" at "env-build.sh: CGO_CFLAGS" to ignore it
//              The "sanitize" is set at "configure" with the "NHI1_SANITIZE" makefile definition and env-Variable
#if !defined(META_ATTRIBUTE_SANITIZE)
# define META_ATTRIBUTE_SANITIZE  __attribute__((no_sanitize("address")))
#endif
 
// define:      META_MEM_DEBUG
// target:      libmqmsgque internal, cache_mq.c etc
// default:     not set = use the cache
// action:      disable reuse of memory
// definition:  libmqmsgque is using the CACHE to reuse a deleted instance and memory.
//              To debug the memory this "reuse" is a problem.
 
//#define META_MEM_DEBUG
 
// define:      META_LOG_CLICKS
// target:      libmqmsgque internal, logging additional clicks-timestamp
// default:     not set = no clicks-timestamp
// action:      add clicks-timestamp to output
// definition:  libmqmsgque is using an verbose logging prefix to help debbugging
//              multi-thread/proc software - with META_LOG_CLICKS an additional
//              column with "clicks" data is added
// attention:   debug_mk.h also needs the "META_LOG_CLICKS", but is usually loaded before msgque_mq.h
 
//#if !defined(META_LOG_CLICKS)
//  #define META_LOG_CLICKS
//#endif
 
// define:      META_PERF_DEBUG
// target:      libmqmsgque internal, disable some inline to create better code for callgrind
// default:     not set = no performance debugging
// action:      add performance debugging features
// definition:  inline code is embedded into calling code, this is faster BUT make it impossible
//              to analyse a single inlined function for performance optimization
 
//#define META_PERF_DEBUG
 
// define:      META_DISABLE_LOG
// target:      command-line definition for compiling
// default:     not set = show logging based on MkDLogC and MkDLogV
// action:      hide logging macros
// definition:  logging is done using so called logging-macros. if META_DISABLE_LOG is defined the logging-macros
//              will dissappear.
 
//#define META_DISABLE_LOG
 
// define:      META_DOXYGEN_USE_C_PRIVAT
// target:      the doxygen configuration files.
// default:     yes=1 - on compillation, no=0 on documentation if NOT defined as 1
// action:      add / hide code and documentation
// definition:  use/hide private code/documentation from doxygen docu and compilation
//              the private code/documentation is only use in "C" compiling and documantation,
//              use this switch to hide this code/documentation from non "C" languages 
 
#ifndef META_DOXYGEN_USE_C_PRIVAT
# ifdef META_DOXYGEN_SHOULD_SKIP_THIS
#  define META_DOXYGEN_USE_C_PRIVAT 0
# else
#  define META_DOXYGEN_USE_C_PRIVAT 1
# endif
#endif
 
// define:      META_STATIC
// target:      build and target, library and executable
// default:     not set -> do NOT force static linking
// action:      build (static) internal and external library
// definition:  ...
 
#ifdef META_STATIC
# undef MK_C_BUILD_DLL
# define MK_C_BUILD_DLL
# undef META_IGNORE_EXTERN
# define META_IGNORE_EXTERN
#endif
 
// define:      META_TYPE_DEBUG
// target:      meta library with type support
// default:     depend on _DEBUG -> add simple type debug code
// action:      add extra type debug code
// definition:  0 = NO debug
//              1 = ADD debug but invisible
//              2 = ADD debug AND add extra logging, (only for a type debugging session)
 
//#define META_TYPE_DEBUG 2
 
#ifndef META_TYPE_DEBUG
# ifdef _DEBUG
#   define META_TYPE_DEBUG 1
# else
#   define META_TYPE_DEBUG 0
# endif
#endif
 
#if META_TYPE_DEBUG == 2
# define META_TYPE_DEBUG__printV(...) printV(__VA_ARGS__)
#else
# define META_TYPE_DEBUG__printV(...)
#endif
 
/*****************************************************************************/
/*                                                                           */
/*        add feature - used to compile 'libmqmsgque' library itself           */
/*                                                                           */
/*****************************************************************************/
 
// DOKU: MkObjectS->selfRefCount
#define META_USE_SELF_REFCOUNT
 
/* ############################################################### */
/* ###                                                         ### */
/* ###                        PARSER                           ### */
/* ###                                                         ### */
/* ############################################################### */
 
// META_P
 
// [__parser__]
#ifndef __has_parser__
 
 
# define __parser__(...) 
# define __parser__define__(...)
 
# define __parser__push__(...)
# define __parser__pop__
 
// END: local attributes
 
 
# define __parser__global__(...)
# define __parser__global__define__(...)
# define __parser__global__push__(...)
# define __parser__global__pop__
 
// END: global attributes
 
#else
# include "parser_mk.h"
#endif
// END: !__has_parser__
// [__parser__]
 
// MkKernel_Parser_C_API
 
/* ############################################################### */
/* ###                                                         ### */
/* ###                         START                           ### */
/* ###                                                         ### */
/* ############################################################### */
 
 
// =========================================================================
 
__parser__(library=MkKernel@internal@Mk);
 
// GLOBAL: all "fmtobj" arguments become attribute "formatter"
__parser__global__(formatter=fmtobj);
#define MK_PARSER_fmtobj  MK_OBJN fmtobj __parser__(default=NULL)
 
// GLOBAL: all "macros" become hide
__parser__global__(hide-rx=^Mk\w+_T$);
 
// END: global __parser__ definition
 
#if defined(_MSC_VER)
 
  // Visual C++ Express-Edition
 
  # define __attribute__(dummy)
  # define __func__ __FUNCTION__
  # define MK_CLRCALL __clrcall
  # define MK_STDCALL __stdcall
  # define MK_CDECL __cdecl
 
  // helper
  # ifndef PARSE_C_HEADER_TO_META
  #  define mk_inline      static inline
  # endif
  //# define bool int
  # define mk_unlink      _unlink
  # define mk_snprintf    _snprintf
 
  # define MK_ATTR_HOT    ???
  # define MK_ATTR_COLD   ???
 
#else   // !_MSC_VER
 
  // GCC
 
  # define MK_CLRCALL
  # define MK_STDCALL
  # define MK_CDECL
 
  // helper
  # ifndef PARSE_C_HEADER_TO_META
  #  define mk_inline     static inline
  # endif
  # define mk_unlink      unlink
  # define mk_snprintf    snprintf
 
  # define MK_ATTR_HOT    __attribute__((hot))
  # define MK_ATTR_COLD   __attribute__((cold))
 
#endif // _MSC_VER
 
#if defined(_MANAGED)
  # define MK_DECL MK_CLRCALL
#elif defined(META_COMPILE_AS_CC)
  # define MK_DECL MK_STDCALL
#else
  # define MK_DECL MK_CDECL
#endif
 
/* BEGIN_MK_C_DECLS should be used at the beginning of your declarations,
  so that C++ compilers don't mangle their names.  Use END_MK_C_DECLS at
  the end of C declarations. */
 
#undef BEGIN_MK_C_DECLS
#undef END_MK_C_DECLS
#if defined(META_COMPILE_AS_CC)
# define BEGIN_MK_C_DECLS namespace libmkkernel {
# define END_MK_C_DECLS }
#elif defined(__cplusplus)
# define BEGIN_MK_C_DECLS extern "C" {
# define END_MK_C_DECLS }
#else
# define BEGIN_MK_C_DECLS /* empty */
# define END_MK_C_DECLS /* empty */
#endif
 
/* Somewhere in the middle of the GCC 2.96 development cycle, we implemented
   a mechanism by which the user can annotate likely branch directions and
   expect the blocks to be reordered appropriately.  Define __builtin_expect
   to nothing for earlier compilers.  */
 
#if defined(_MSC_VER) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
  #define likely(x)       !!(x)
  #define unlikely(x)     !!(x)
  #else
  #define likely(x)       __builtin_expect((x),1)
  #define unlikely(x)     __builtin_expect((x),0)
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  # ifndef _MSC_VER
    # include <inttypes.h>
  # endif
  # ifdef __CYGWIN__
    # include <windef.h>
  # endif
  # include <stdarg.h>
  # include <stdio.h>
  # include <time.h>
  # include <limits.h>
  # include <string.h>
  # ifndef _MSC_VER
    # include <unistd.h>
    # include <stdbool.h>
  # endif
#endif
 
#if defined(_WIN32) && !defined(__CYGWIN__)
  # ifndef PARSE_C_HEADER_TO_META
  #   include <winsock2.h>
  # endif
 
  # define mk_timeval timeval
 
  struct mk_timezone {
    int  tz_minuteswest;      
    int  tz_dsttime;          
  };
 
#else
  # define mk_timeval timeval
  # define mk_timezone timezone
    struct mk_timeval;
    struct mk_timezone;
#endif
 
#define MK_UNUSED __attribute__((unused))
#define MK_NO_RETURN 
//#define MK_NO_RETURN __attribute__((noreturn))
#define MK_UNREACHABLE __builtin_unreachable()
// https://stackoverflow.com/questions/20110291/use-cases-of-the-gcc-artificial-function-attribute
#define MK_ARTIFICIAL __attribute__((__artificial__)) 
 
#ifndef PARSE_C_HEADER_TO_META
  # include <assert.h>
#endif
 
// END: native compiler definition
 
// END: MkKernel_Compiler_C_API
 
// Namespace for the 'ccmkkernel' API …
BEGIN_MK_C_DECLS
 
// ==============================================================================================
 
typedef void* MK_MACRO_TYP;
 
 
__parser__(ignore)
#define MK_NULL NULL
 
#define MK_NULL_YES true
 
#define MK_NULL_NO false
 
__parser__(ignore)
#define MK_NULL_STR "MK_NULL"
 
__parser__(ignore)
#define MK_NULL_STR_LEN strlen(MK_NULL_STR)
 
__parser__(ignore)
mk_inline bool MK_NULL_STR_CHECK(char const * const __str, const long int __len) {
  return ((__str) ? ( (__len) == MK_NULL_STR_LEN && strcmp((__str),MK_NULL_STR)==0 ) : true);
}
 
__parser__(ignore)
mk_inline bool MK_NULL_STR_CHECK_1(char const * const __str) {
  return ((__str) ? strcmp((__str),MK_NULL_STR)==0 : true);
}
 
__parser__(ignore)
mk_inline bool MK_NULL_STR_OR_EMPTY_CHECK_1(char const * const __str) {
  return ((__str) ? (__str)[0] == '\0' || strcmp((__str),MK_NULL_STR)==0 : true);
}
 
// name: MK_NULL
 
// MkKernel_Compiler_C_API
 
// ==============================================================================================
#if 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)         MkRT_O(o),
  # define MK_RT_CALL_X(x)         MkRT_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)      ptr,
  # define MK_PARSER_RT_ONLY       MK_RT_ARGS_ONLY __parser__(internal,default=N#RUNTIME)
  # define MK_PARSER_RT            MK_PARSER_RT_ONLY,
#else
  # define MkThreadLocal
  # define MK_RT_SHIFT             0
  # define MK_RT_ARGS_ONLY         void
  # define MK_RT_ARGS
  # define MK_RT_CALL_ONLY
  # define MK_RT_CALL
  # define MK_RT_CALL_O(o)         
  # define MK_RT_CALL_X(x)         
  # define MK_RT_CALL_NULL_ONLY
  # define MK_RT_CALL_NULL
  # define MK_RT_NULL
  # define MK_RT_PTR               (&MkRuntimeRLS)
  # define MK_RT_REF               (MkRuntimeRLS)
  # define MK_RT_REF_NULL          (MkRuntimeRLS)
  # define MK_RT_UNUSED
  # define MK_RT_CALL_RT(ptr)
  # define MK_PARSER_RT_ONLY       void
  # define MK_PARSER_RT
#endif
 
# 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)))
 
// nonnull for runtime yesORno? → problem is C# (and propably go), because runtime is a C feature and getting a nonnull C Pointer
// for every API call in C# is expensive. solution? → allow NULL and resolve the mkrt pointer in C
# define __MK_ATTR_RT_RUNTIME      // empty
 
#if META_HDL_USE__NONNULL__GCC_ATTRIBUTE == 1
  // with "nonnull" on HDL the assert disable itself
  # define __MK_ATTR_RT_INSTANCE        __attribute__((nonnull(1+MK_RT_SHIFT)))
  # define __MK_ATTR_INSTANCE           __attribute__((nonnull(1)))
  # define MK_INSTANCE_HDL(x)
#else
  # define __MK_ATTR_RT_INSTANCE          
  # define __MK_ATTR_INSTANCE
  # define MK_INSTANCE_HDL(x)           assert(x!=NULL)
#endif
 
// ".h" file
#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)
 
// ".c" file
#define MK_INSTANCE_RT_X(x)             MK_INSTANCE_HDL(x); MkRtSetup_XN_RT(x)
#define MK_INSTANCE_RT_XN(x)                                MkRtSetup_X_RT(x)
#define MK_INSTANCE_RT_O(o)             MK_INSTANCE_HDL(o); MkRtSetup_ON_RT(o)
#define MK_INSTANCE_RT_ON(o)                                MkRtSetup_O_RT(o)
#define MK_DESTRUCTOR_RT_X(c,x)         MK_INSTANCE_HDL(x);        \
                                        if (!MkCheckNN(c,x)) return;    /* do NOT delete an invalid pointer */ \
                                        MkRtSetup_XN_RT(x)
#define MK_STATIC_RT                    MkRtSetup_NULL_RT
 
// example: probably future enhancement on class/method definition 
// #define MK_INLINE_RT_STATIC(func,...)  mk_inline MK_ATTR_RT_STATIC func##_RT (MK_PARSER_RT __VA_ARGS__)
 
// MkRuntimeC_Interface_C_API
 
// MARK_O
#ifndef PARSE_C_HEADER_TO_META
  # include "gen/kernel_overload_mk.h"
#endif
 
/*****************************************************************************/
/*                                                                           */
/*                    compiler and os definition                             */
/*                                                                           */
/*****************************************************************************/
 
 
// on windows using the 'native' compiler 'cl.exe' we have to define some missing symbols
#if defined(_MSC_VER) && defined(_DLL)
  # undef PIC
  # define PIC
  # undef DLL_EXPORT
  # define DLL_EXPORT
#endif
 
#ifdef META_IS_WINDOWS
  # define META_DIR_SEPARATOR '\\'
  # define META_EOL "\r\n"
#else
  # define META_DIR_SEPARATOR '/'
  # define META_EOL "\n"
#endif
 
// BEGIN-HEADER - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// If the source of libmkkernel is direct used in an external library
// (without dynamic linking) and this library should *not* export
// the symbol's of libmkkernel then the flag META_IGNORE_EXTERN have
// to be set
#undef MK_EXTERN
#if defined(META_IGNORE_EXTERN)
#   define MK_EXTERN
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_C_BUILD_DLL)
#        define MK_EXTERN __declspec(dllexport)
#      else
#        define MK_EXTERN __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_EXTERN __attribute__ ((visibility("default")))
#  endif
#else
#   define MK_EXTERN
#endif
 
// external data lookup
#undef MK_EXTERN_DATA
#if defined(META_PRIVATE)
#  define MK_EXTERN_DATA extern
#elif defined(META_IGNORE_EXTERN)
#  define MK_EXTERN_DATA extern
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmkkernel library ?
#      if defined(MK_C_BUILD_DLL)
#        define MK_EXTERN_DATA __declspec(dllexport)
#      else
#        define MK_EXTERN_DATA __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define MK_EXTERN_DATA __attribute__ ((visibility("default"))) extern
#  endif
#else
#  define MK_EXTERN_DATA extern
#endif
 
// END-HEADER - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define MK_CPPXSTR(s) MK_CPPSTR(s)
#define MK_CPPSTR(s) #s
#define MK_CONCAT(a,b) a ## b
#define MK_CONCAT2(a,b) MK_CONCAT(a,b)
#define MK_CONCAT3(a,b,c) a ## b ## c
 
#ifdef HAVE_STPCPY
  #define mk_append_fix_str(t,s) t=stpcpy(t,s)
#else
  #define mk_append_fix_str(t,s) t=strcpy(t,s)+sizeof(s)-1
#endif
 
#define mk_bit_compare(t,f) (t&f)==f
 
// MkKernel_Compiler_C_API
 
/* MARK_T ********************************************************************/
/*                                                                           */
/*                            types/generic                                  */
/*                                                                           */
/*****************************************************************************/
 
 
struct MkErrorS;
struct MkBufferListS;
struct MkBufferS;
union  MkBufferU;
struct MkObjectS;
struct MkAllocS;
struct MkTypeS;
struct MkSuperTypeS;
 
#define MK_ALFA '@'
#define MK_ALFA_STR ((MkStringR){1,"@"})
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_NB1_MK_BOL:"1 byte 'boolean' data-type")
typedef unsigned char MK_BOL;
 
// hint: bool into printf %B → https://stackoverflow.com/questions/17307275/what-is-the-printf-format-specifier-for-bool
__parser__(type=ME_NB0_MK_BOOL:"'boolean' data-type":primary)
typedef bool MK_BOOL;
#define bool2str(_bool) (_bool?"true":"false")
 
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_NI1_MK_I8:"1 byte 'byte' data-type")
typedef signed char MK_I8;
__parser__(type=ME_NI2_MK_I16:"2 byte 'short integer' data-type":primary:int16_t)
typedef signed short int MK_I16;
__parser__(type=ME_NI4_MK_I32:"4 byte 'integer' data-type":primary:int32_t)
typedef signed int MK_I32;
#if defined(_MSC_VER)
  typedef __int64 MK_I64;
  typedef long MK_SIZE;
#else
  __parser__(type=ME_NI8_MK_I64:"8 byte 'wide integer' data-type":primary:int64_t)
  typedef signed long long MK_I64;
#endif
__parser__(type=ME_NIL_MK_LONG:"4/8 byte 'long' data-type":primary)
// TODO → make MK_LONG network save
typedef long MK_LONG;
 
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_NU1_MK_U8:"1 byte 'unsigned byte' data-type":primary:uint8_t)
typedef unsigned char MK_U8;
__parser__(type=ME_NU2_MK_U16:"2 byte 'unsigned short' data-type":primary:uint16_t)
typedef unsigned short MK_U16;
__parser__(type=ME_NU4_MK_U32:"4 byte 'unsigned integer' data-type":primary:uint32_t)
typedef unsigned int MK_U32;
__parser__(type=ME_NU8_MK_U64:"8 byte 'unsigned wide' data-type":primary:uint64_t)
typedef unsigned long long MK_U64;
//__parser__(type=ME_NUX_MK_UXN:"min 8 byte 'unsigned long long' data-type":primary)
//typedef unsigned long long MK_UXN;
__parser__(type=ME_NUL_MK_ULN:"8 byte 'unsigned long' data-type":primary)
typedef unsigned long MK_ULN;
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_NF4_MK_FLT:"4 byte 'float' data-type":primary)
typedef float MK_FLT;
__parser__(type=ME_NF8_MK_DBL:"8 byte 'double' data-type":primary)
typedef double MK_DBL;
 
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_NIH_MK_HDL:"handle data-type")
// also change: MqHigh_jv.c=jint
typedef int32_t MK_HDL;
#define MK_HDL_REF_S3(__prefix) __prefix ##  NI4
#define MK_HDL_REF_S1(__prefix) __prefix ##  I32
#define MK_HDLT MK_I32T
 
// OLD: internal \b hdl used in uplevel-programming-language-shell to store a pointer:
// OLD: \li \e java uses \b jlong equal to \RMKNS{LONG}
// OLD: \li \e csharp uses \b IntPtr equal to \RMKNS{PTR}
// OLD: typedef MK_PTRB *MK_HDL;
 
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_NIL_MK_SIZE:"long byte 'size' datay-type")
// choose "long" because it have to fit a pointer-diff (eg: ptr1-ptr2) without cast
typedef long MK_SIZE;
__parser__(type=ME_RUA_MkBufferAtomU:"atomic native data buffer type")
typedef union MkBufferAtomU MK_ATO;
__parser__(type=ME_NI4_MK_NUM)
typedef int32_t MK_NUM;
#define MK_FORMAT_N     "%i"
 
__parser__(type=ME_NI4_MK_DBG:"debug-level data-type")
typedef int     MK_DBG;
 
__parser__(type=ME_NU4_MK_SIG)
typedef unsigned int MK_SIG;
 
 
// ----------------------------------------------------------------------------------
 
__parser__(type=ME_NIL_MK_TIME_T:"time [sec] data-type")
typedef time_t          MK_TIME_T;
#define MK_FORMAT_TIME  "%li"
#define MK_TIME         ((MK_TIME_T)time(NULL))
#define MK_TIME_MAX     (365*24*60*60)              
 
// ----------------------------------------------------------------------------------
 
 
// attention: "google go" can not uses nested typedef's -> use "#define" for the basic types
 
__parser__(type=ME_PVB_MK_PTRB:"pointer type data-type")
typedef void MK_PTRB;
 
__parser__(type=ME_PVX_MK_PTR:"generic pointer data-type":primary)
typedef MK_PTRB *MK_PTR;
__parser__(type=ME_PVN_MK_PTRN:"const generic pointer data-type":primary)
typedef const MK_PTRB *MK_PTRN;
__parser__(type=ME_PCX_MK_CCP:"class constructor/destructor data type")
typedef MK_PTRB *MK_CCP;
__parser__(type=ME_PAX_MK_CBP:"generic pointer to call-back data")
typedef MK_PTRB *MK_CBP;
__parser__(type=ME_CXC_MK_MNG:"managed object pointer; datatype will be checked at runtime")
typedef MK_PTRB *MK_MNG;
__parser__(type=ME_CXN_MK_MNGN:"const - a managed object pointer; datatype will be checked at runtime")
typedef const MK_PTRB *MK_MNGN;
__parser__(type=ME_PEX_MK_EXP:"target language exception-class-object")
typedef MK_PTRB const *MK_EXP;
__parser__(type=ME_CXC_MkExceptionC:"target language library-exception-class-object")
typedef MK_PTRB *MK_MXP;
 
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_PLB_MK_LSTB:"list type data-type")
typedef unsigned char MK_LSTB;
 
__parser__(type=ME_PLX_MK_LST:"list pointer data-type")
typedef MK_LSTB *MK_LST;
 
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_PBB_MK_BINB:"byte-array type data-type")
typedef unsigned char MK_BINB;
 
__parser__(type=ME_PBX_MK_BIN:"byte-array pointer data-type":primary)
typedef MK_BINB *MK_BIN;
 
__parser__(type=ME_PBN_MK_BINN:"const byte-array pointer data-type":primary)
typedef MK_BINB const *MK_BINN;
 
 
// ----------------------------------------------------------------------------------
 
 
__parser__(type=ME_PSB_MK_STRB:"string type data-type")
typedef char MK_STRB;
 
__parser__(type=ME_PSX_MK_STR:"string pointer data-type":primary)
typedef MK_STRB *MK_STR;
 
__parser__(type=ME_PSN_MK_STRN:"constant string pointer data-type":primary)
typedef const MK_STRB *MK_STRN;
 
__parser__(type=ME_ASN_MK_STRN_A:"ARRAY of MK_STRN")
typedef struct {
  MK_NUM  size;
  MK_STRN  *data;
} MK_STRN_A;
 
__parser__(ignore)
MK_UNUSED const static MK_STRN_A MK_STRN_A_NULL = (MK_STRN_A) {0,0};
 
__parser__(type=ME_PFX_MK_FST:"constant 'printf' format string")
typedef MK_STRB const *MK_FST;
 
 
// ----------------------------------------------------------------------------------
 
__parser__(type=ME_PVX_MK_NAT_OBJECT:"target language object pointer")
typedef void*   MK_NAT_OBJECT;
__parser__(type=ME_PVX_MK_NAT_LIST:"target language list pointer")
typedef void*   MK_NAT_LIST;
 
// ----------------------------------------------------------------------------------
 
// MkKernel_Type_C_API
 
/* MARK_C ********************************************************************/
/*                                                                           */
/*                            class types                                    */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-ShortDef - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__(type=ME_CCC_MkObjectC:"MkObjectC class handle":primary)
  typedef struct MkObjectS * MK_OBJ;
  __parser__(type=ME_CCN_MkObjectC:"const - MkObjectC class handle":primary)
  typedef const struct MkObjectS * MK_OBJN;
  __parser__(ignore)
  typedef struct MkObjectS   MK_OBJR;
// MkObjectC_Class_C_API
 
  __parser__(type=ME_CCC_MkBufferC:"MkBufferC class handle":primary)
  typedef struct MkBufferS * MK_BUF;
  __parser__(type=ME_CCN_MkBufferC:"const - MkBufferC class handle":primary)
  typedef const struct MkBufferS * MK_BUFN;
  __parser__(ignore)
  typedef struct MkBufferS   MK_BUFR;
// MkBufferC_Class_C_API
 
  __parser__(type=ME_CCC_MkBufferStreamC:"MkBufferStreamC class handle":primary)
  typedef struct MkBufferStreamS * MK_BUS;
  __parser__(type=ME_CCN_MkBufferStreamC:"const - MkBufferStreamC class handle":primary)
  typedef const struct MkBufferStreamS * MK_BUSN;
  __parser__(ignore)
  typedef struct MkBufferStreamS   MK_BUSR;
// MkBufferStreamC_Class_C_API
 
  __parser__(type=ME_CCC_MkBufferListC:"MkBufferListC class handle":primary)
  typedef struct MkBufferListS * MK_BFL;
  __parser__(type=ME_CCN_MkBufferListC:"const - MkBufferListC class handle":primary)
  typedef const struct MkBufferListS * MK_BFLN;
  __parser__(ignore)
  typedef struct MkBufferListS   MK_BFLR;
// MkBufferListC_Class_C_API
 
  __parser__(type=ME_CCC_MkLogFileC:"MkLogFileC class handle":primary)
  typedef struct MkLogFileS * MK_LFL;
  __parser__(type=ME_CCN_MkLogFileC:"const - MkLogFileC class handle":primary)
  typedef const struct MkLogFileS * MK_LFLN;
  __parser__(ignore)
  typedef struct MkLogFileS   MK_LFLR;
// MkLogFileC_Class_C_API
 
  __parser__(type=ME_CCC_MkErrorC:"MqErrorC class handle":primary)
  typedef struct MkErrorS * MK_ERR;
  __parser__(type=ME_CCN_MkErrorC:"const - MqErrorC class handle":primary)
  typedef const struct MkErrorS * MK_ERRN;
  __parser__(ignore)
  typedef struct MkErrorS   MK_ERRR;
// MkErrorC_Class_C_API
 
  __parser__(internal,type=ME_CCC_MkExtensionC:"abstract class for the extension technology":internal)
  typedef struct MkExtensionS * MK_EXT;
  __parser__(internal,type=ME_CCN_MkExtensionC:"const - abstract class for the extension technology":internal)
  typedef const struct MkExtensionS * MK_EXTN;
  __parser__(ignore)
  typedef struct MkExtensionS   MK_EXTR;
// MkExtensionC_Class_C_API
 
  __parser__(internal,type=ME_CCC_MkErrExtC:"final class for the MkErrorS extention technology":internal)
  typedef struct MkErrExtS * MK_ERREXT;
  __parser__(internal,type=ME_CCN_MkErrExtC:"const - final class for the MkErrorS extention technology":internal)
  typedef const struct MkErrExtS * MK_ERREXTN;
  __parser__(ignore)
  typedef struct MkErrExtS   MK_ERREXTR;
// MkErrExtC_Class_C_API
 
  __parser__(internal,type=ME_CCC_MkRtExtC:"final class for the MkRuntimeS extention technology":internal)
  typedef struct MkRtExtS * MK_RTEXT;
  __parser__(internal,type=ME_CCN_MkRtExtC:"const - final class for the MkRuntimeS extention technology":internal)
  typedef const struct MkRtExtS * MK_RTEXTN;
  __parser__(ignore)
  typedef struct MkRtExtS   MK_RTEXTR;
// MkRtExtC_Class_C_API
 
  __parser__(type=ME_CCC_MkRuntimeC:"runtime singleton class object":primary)
  typedef struct MkRuntimeS * MK_RT;
  __parser__(type=ME_CCN_MkRuntimeC:"const - runtime singleton class object":primary)
  typedef const struct MkRuntimeS * MK_RTN;
  __parser__(ignore)
  typedef struct MkRuntimeS   MK_RTR;
// MkRuntimeC_Class_C_API
 
  __parser__(internal,type=ME_CCC_MkTypeC:"a managed object class type !base! pointer":internal)
  typedef struct MkTypeS * MK_TYP;
  __parser__(internal,type=ME_CCN_MkTypeC:"const - a managed object class type !base! pointer":internal)
  typedef const struct MkTypeS * MK_TYPN;
  __parser__(ignore)
  typedef struct MkTypeS   MK_TYPR;
// MkTypeC_Class_C_API
 
// END-ShortDef - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(type=ME_CXC_MK_BAC:"a list of 'buffer' as last argument in function")
typedef struct MkBufferListS *MK_BAC;
 
__parser__(type=ME_CXN_MK_BAC:"const - a list of 'buffer' as last argument in function")
typedef const struct MkBufferListS *MK_BACN;
 
// --------------------------------------------------------------------
// binary
 
 
__parser__push__(hide);
 
__parser__(reference)
typedef struct {
  MK_SIZE size;   
  MK_BINN data;   
} MkBinaryR;
 
MK_ATTR_STATIC 
mk_inline MkBinaryR MkBinaryCreate ( MK_SIZE size, MK_BINN data ) {
   return (MkBinaryR) {size, data};
}
 
MK_ATTR_STATIC
mk_inline bool MkBinaryIsNull ( const MkBinaryR bin ) {
  return bin.data == NULL;
}
 
MK_ATTR_STATIC
mk_inline const MkBinaryR MkBinaryCreateSlice ( const MkBinaryR bin, MK_SIZE start, MK_SIZE wide ) {
  if (start>bin.size) 
    return (const MkBinaryR) {0, NULL};
  else
    return (const MkBinaryR) {start+wide>bin.size?bin.size-start:wide, bin.data+start};
}
 
MK_ATTR_RT_STATIC
mk_inline MkBinaryR MkBinaryDup_RT ( MK_PARSER_RT const MkBinaryR bin );
 
MK_ATTR_RT_STATIC
mk_inline void MkBinaryLog_RT ( MK_PARSER_RT const MkBinaryR bin );
 
MK_ATTR_STATIC
mk_inline MK_BINN MkBinaryGetData ( const MkBinaryR bin ) {
  return bin.data;
}
 
MK_ATTR_STATIC
mk_inline MK_SIZE MkBinaryGetSize ( const MkBinaryR bin ) {
  return bin.size;
}
 
__parser__pop__;
 
// MkKernel_Binary_C_API
 
 
__parser__push__(hide);
 
// [MkStringR]
__parser__(reference)
typedef struct {
  MK_NUM  len;   
  MK_STRN ptr;   
} MkStringR;
// [MkStringR]
 
MK_ATTR_RT_STATIC
mk_inline void MkStringLog_RT ( MK_PARSER_RT MkStringR const str, MK_STRN func ) ;
 
MK_ATTR_STATIC
mk_inline MkStringR MkStringCreate ( MK_NUM len, MK_STRN str ) {
  return (MkStringR) {(len>0?len:str?(MK_NUM)strlen(str):0), str};
}
 
MK_ATTR_STATIC
mk_inline MkStringR MkStringCreate_1 ( MK_STRN str ) {
  return (MkStringR) {str?(MK_NUM)strlen(str):0, str};
}
 
MK_ATTR_STATIC
mk_inline MkStringR MkStringSlice ( MkStringR strR, MK_NUM start, MK_NUM len ) {
  if (len < 0) len = strR.len;
  if (start > strR.len) {
    return MkStringCreate(0,NULL);
  } else if ((start+len) > strR.len) {
    return MkStringCreate(strR.len-start,strR.ptr+start);
  } else {
    return MkStringCreate(len,strR.ptr+start);
  }
}
 
MK_ATTR_STATIC
mk_inline void MkStringSplit ( MkStringR strR, MK_NUM *len_out, MK_STRN *str_out ) {
  assert(len_out != NULL);
  assert(str_out != NULL);
  *len_out = strR.len; *str_out = strR.ptr;
}
 
MK_ATTR_RT_STATIC
mk_inline MkStringR MkStringDup_RT ( MK_PARSER_RT MkStringR const str );
 
MK_ATTR_STATIC
mk_inline MK_STRN MkStringGetData ( MkStringR const str ) {
  return str.ptr;
}
 
MK_ATTR_STATIC
mk_inline MK_NUM MkStringGetSize ( MkStringR const str ) {
  return str.len;
}
 
MK_ATTR_STATIC
mk_inline bool MkStringIsNULL(MkStringR const strR) {
  return ((strR.ptr) && (strR.len) == MK_NULL_STR_LEN && strcmp((strR.ptr),MK_NULL_STR)==0);
}
 
__parser__pop__;
 
// - MkKernel_String_C_API
 
/*****************************************************************************/
/*                                                                           */
/*                            enum definitions                               */
/*                                                                           */
/*****************************************************************************/
 
 
__parser__push__(doc-group=Enum);
 
 
// [MkErrorE]
enum MkErrorE {
  MK_OK         = 0,            
  MK_CONTINUE   = 1,            
  MK_ERROR      = 2,            
};
// [MkErrorE]
 
// BEGIN-MkErrorE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_EXTERN MK_STRN MK_DECL MkErrorE_ToString  ( enum MkErrorE value ) MK_ATTR_STATIC ;
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_ATTR_STATIC
mk_inline MK_I32 MkErrorE_ToInt ( enum MkErrorE value ) {
  return (MK_I32) value;
}
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc)
MK_EXTERN enum MkErrorE MkErrorE_FromInt ( MK_I32 const value, enum MkErrorE * value_out ) MK_ATTR_STATIC ;
 
// END-MkErrorE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// additional attribute for MkErrorE_FromInt - this function return TWO errors 1) return and 2) the value_out
__parser__global__(MkErrorE_FromInt:error-ignore=2);
 
// MkErrorE
 
 
// [MkTimeoutE]
__parser__(enum-accept-integer=long)
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,
};
// [MkTimeoutE]
 
// BEGIN-MkTimeoutE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_EXTERN MK_STRN MK_DECL MkTimeoutE_ToString  ( enum MkTimeoutE value ) MK_ATTR_STATIC ;
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_ATTR_STATIC
mk_inline MK_I32 MkTimeoutE_ToInt ( enum MkTimeoutE value ) {
  return (MK_I32) value;
}
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc)
MK_EXTERN enum MkErrorE MkTimeoutE_FromInt ( MK_I32 const value, enum MkTimeoutE * value_out ) MK_ATTR_STATIC ;
 
// END-MkTimeoutE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__(internal)
enum MkBoolE {
  MK_NO   = 0,   
  MK_YES  = 1,   
};
 
// BEGIN-MkBoolE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(internal,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_EXTERN MK_STRN MK_DECL MkBoolE_ToString  ( enum MkBoolE value ) MK_ATTR_STATIC ;
 
__parser__(internal,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_ATTR_STATIC
mk_inline MK_I32 MkBoolE_ToInt ( enum MkBoolE value ) {
  return (MK_I32) value;
}
 
__parser__(internal,no-rpc,prefix=EnumFunc)
MK_EXTERN enum MkErrorE MkBoolE_FromInt ( MK_I32 const value, enum MkBoolE * value_out ) MK_ATTR_STATIC ;
 
// END-MkBoolE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
// [MkNativeIsE]
__parser__(internal)
enum MkNativeIsE {
  MK_NATIVE_IS_INITIAL  = 0,      
  MK_NATIVE_IS_STRING   = 'S',    
  MK_NATIVE_IS_LITTLE   = 'L',    
  MK_NATIVE_IS_BIG      = 'B',    
};
// [MkNativeIsE]
 
// BEGIN-MkNativeIsE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(internal,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_EXTERN MK_STRN MK_DECL MkNativeIsE_ToString  ( enum MkNativeIsE value ) MK_ATTR_STATIC ;
 
__parser__(internal,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_ATTR_STATIC
mk_inline MK_I32 MkNativeIsE_ToInt ( enum MkNativeIsE value ) {
  return (MK_I32) value;
}
 
__parser__(internal,no-rpc,prefix=EnumFunc)
MK_EXTERN enum MkErrorE MkNativeIsE_FromInt ( MK_I32 const value, enum MkNativeIsE * value_out ) MK_ATTR_STATIC ;
 
// END-MkNativeIsE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkNativeIsE
 
 
#define MK_TYPE_IS_1_I8E   (1<<0)
 
#define MK_TYPE_IS_2_I8E   (1<<1)
 
#define MK_TYPE_IS_4_I8E   (1<<2)
 
#define MK_TYPE_IS_8_I8E   (1<<3)
 
#define MK_TYPE_IS_NATIVE   (   MK_TYPE_IS_1_I8E | MK_TYPE_IS_2_I8E |       \
                                MK_TYPE_IS_4_I8E | MK_TYPE_IS_8_I8E     )
 
#define MK_TYPE_SHIFT       4       
 
// [MkTypeE]
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)                     ),  
};
// [MkTypeE]
 
// BEGIN-MkTypeE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_EXTERN MK_STRN MK_DECL MkTypeE_ToString  ( enum MkTypeE value ) MK_ATTR_STATIC ;
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_ATTR_STATIC
mk_inline MK_I32 MkTypeE_ToInt ( enum MkTypeE value ) {
  return (MK_I32) value;
}
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc)
MK_EXTERN enum MkErrorE MkTypeE_FromInt ( MK_I32 const value, enum MkTypeE * value_out ) MK_ATTR_STATIC ;
 
// END-MkTypeE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkTypeE
 
__parser__pop__;
 
// MkKernel_Enum_C_API
 
 
__parser__(ignore)
union MkBufferAtomU {
  MK_I8     I8;                 
  MK_BOL    BOL;                
  MK_I16    I16;                
  MK_I32    I32;                
  MK_FLT    FLT;                
  MK_I64    I64;                
  MK_DBL    DBL;                
  MK_BINB   B[8];               
  MK_BINB   B8[8];              
  MK_BINB   B4[4];              
  MK_BINB   B2[2];              
  MK_BINB   B1[1];              
 
#if defined(__cplusplus)
  MkBufferAtomU()           : I64(0L) {};
  MkBufferAtomU(MK_I8  val) : I8(val) {};
  MkBufferAtomU(MK_BOL val) : BOL(val) {};
  MkBufferAtomU(MK_I16 val) : I16(val) {};
  MkBufferAtomU(MK_I32 val) : I32(val) {};
  MkBufferAtomU(MK_I64 val) : I64(val) {};
  MkBufferAtomU(MK_FLT val) : FLT(val) {};
  MkBufferAtomU(MK_DBL val) : DBL(val) {};
#endif
};
 
__parser__(ignore)
union MkBufferU {
  MK_ATO  *A;                   
  MK_BIN  B;                    
  MK_STRN C;                    
  MK_STR  S;                    
  MK_LST  L;                    
};
 
#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
 
// MkKernel_PrimitiveType_C_API
 
 
 
// =============================================================================================
 
 
typedef uintptr_t MK_IDNT;
 
// also: theLink/cs/libmqmsgque.cs
__parser__(hide)
enum MkIdSE {
  MK_ID_UNUSED  = 0,        
  MK_ID_PROCESS = 1,        
  MK_ID_THREAD  = 2         
};
 
// BEGIN-MkIdSE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_EXTERN MK_STRN MK_DECL MkIdSE_ToString  ( enum MkIdSE value ) MK_ATTR_STATIC ;
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc,return-type-default-no)
MK_ATTR_STATIC
mk_inline MK_I32 MkIdSE_ToInt ( enum MkIdSE value ) {
  return (MK_I32) value;
}
 
__parser__(doc-group=Enum,doc-index=_ignore_,class=MkKernel,no-rpc,prefix=EnumFunc)
MK_EXTERN enum MkErrorE MkIdSE_FromInt ( MK_I32 const value, enum MkIdSE * value_out ) MK_ATTR_STATIC ;
 
// END-MkIdSE - created by 'c_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// also: theLink/cs/libmqmsgque.cs
__parser__(hide)
struct MkIdS {
  enum MkIdSE type;         
  MK_IDNT     val;          
  bool        ioIsPipe;     
};
 
 
/*****************************************************************************/
/*                                                                           */
/*                           cache                                           */
/*                                                                           */
/*****************************************************************************/
 
 
__parser__(ignore)
typedef MK_PTR  ( *MkCacheCF) ( MK_RT_ARGS MK_PTR const);
__parser__(ignore)
typedef void    ( *MkCacheDF) ( MK_RT_ARGS MK_PTR * const);
 
__parser__(ignore)
struct MkCacheItemS {
  #define MkCacheItemS_signature 0x44196912
  MK_SIG signature;             
  bool   doFree;                
  struct MkCacheItemS * prev;   
  struct MkCacheItemS * next;   
  MK_PTR data;                  
};
 
__parser__(ignore)
struct MkCacheS {
  MK_RT runtime;                      
#define MkCacheS_name_size  32
  MK_STRB name[MkCacheS_name_size];   
  struct MkCacheItemS * used;         
  struct MkCacheItemS * free_first;   
  struct MkCacheItemS * free_last;    
  MkCacheCF createF;                  
  MkCacheDF deleteF;                  
  MK_PTR createD;                     
  MK_NUM num;                         
 
#define MkCacheS_MkCacheItemS_size  8
  struct MkCacheItemS     MkCacheItemS_A[MkCacheS_MkCacheItemS_size];
  MK_NUM                  MkCacheItemS_N;
};
 
// MkKernel_Cache_C_API
 
__parser__(flags=public-internal)
typedef void ( MK_DECL *MkMarkF ) ( MK_RT_ARGS MK_PTR data );
 
/*****************************************************************************/
/*                                                                           */
/*                           create / delete                                 */
/*                                                                           */
/*****************************************************************************/
 
__parser__push__(no-rpc,template-overload,doc-group=libmkkernel,doc-index=Setup,prefix=Setup);
 
__parser__(no-inline)
MK_EXTERN void MK_DECL MkSetup (void) __attribute__ ((constructor(200))) MK_ATTR_STATIC ;
 
__parser__(no-inline)
MK_EXTERN void MK_DECL MkCleanup (void) __attribute__ ((destructor(200))) MK_ATTR_STATIC ;
 
__parser__(ignore)
MK_EXTERN_DATA bool MkCleanupActive;
 
__parser__(internal)
MK_EXTERN bool MK_DECL MkHasThread (void);
 
__parser__(internal)
MK_EXTERN bool MK_DECL MkHasFork (void);
 
__parser__pop__;
 
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                     S Y S T E M - A P I                         ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
// MkObjectC_Sys_C_API: hide all ^MkSys
__parser__global__(hide-rx=^MkSys);
// MkObjectC_Sys_C_API: default class for MkSys is MkObjectC
__parser__global__(prefix2class:MkSys=MkObjectC);
 
 
__parser__push__(internal); // \{ internal
 
typedef MK_PTR (*MkSysCallocF) (size_t, size_t) __attribute__ ((alloc_size (1, 2)));
 
typedef MK_PTR (*MkSysMallocF) (size_t) __attribute__ ((alloc_size (1)));
 
typedef MK_STR (*MkSysStrDupF) (MK_STRN);
 
typedef MK_STR (*MkSysStrNCpyF) (char*,const char*,size_t);
 
typedef MK_STR (*MkSysStrNDupF) (MK_STRN, size_t) __attribute__ ((alloc_size (2)));
 
typedef MK_PTR (*MkSysReallocF) (MK_PTR, size_t);
 
typedef void (*MkSysFreeF) (MK_PTR);
 
typedef pid_t (*MkSysForkF) (void);
 
typedef enum MkErrorE (*MkSysWaitF) (
  MK_OBJN const   fmtobj,
  MK_IDNT const   id
);
 
typedef void (*MkSysExitF) (
  MK_RT_ARGS
  int                     isThread,
  int                     num
) MK_NO_RETURN;
 
__parser__(ignore)
struct MkLalS {
  MkSysCallocF            SysCalloc;
  MkSysMallocF            SysMalloc;
  MkSysReallocF           SysRealloc;
  MkSysStrNDupF           SysStrNDup;
  MkSysStrDupF            SysStrDup;
  MkSysStrNCpyF           SysStrNCpy;
  MkSysFreeF              SysFree;
  MkSysForkF              SysFork;
  MK_PTR                  SysForkData;
  MkSysWaitF              MkSysWaitForProcessCB;
  MkSysWaitF              MkSysWaitForThreadCB;
 
  enum MkErrorE (*SysUSleep) (
    MK_OBJN const         obj,
    unsigned int const    usec
  );
  enum MkErrorE (*SysSleep) (
    MK_OBJN const         obj,
    unsigned int const    sec
  );
  enum MkErrorE (*SysDaemonize) (
    MK_RT_ARGS
    MK_OBJN const         obj,
    MK_STRN               pidfile
  );
  MkSysExitF              MkSysExitCB;
  void (*SysAbort) (
    void
  ) __attribute__((noreturn));
 
  enum MkErrorE (*SysIgnorSIGCHLD) (
    MK_RT_ARGS
    MK_OBJ const          obj
  );
 
  enum MkErrorE (*SysAllowSIGCHLD) (
    MK_RT_ARGS
    MK_OBJ const          obj
  );
};
 
__parser__(ignore)
MK_EXTERN_DATA struct MkLalS MkLal;
 
__attribute__ ((alloc_size (2, 3)))
__parser__(internal)
MK_EXTERN MK_PTR MK_DECL MkSysCalloc (
  MK_PARSER_fmtobj,
  size_t const nmemb,
  size_t const size
);
 
__attribute__ ((alloc_size (2)))
__parser__(internal)
MK_EXTERN MK_PTR MK_DECL MkSysMalloc (
  MK_PARSER_fmtobj,
  size_t const size
);
 
MK_EXTERN MK_STR MK_DECL MkSysStrDup (
  MK_PARSER_fmtobj,
  MK_STRN const str
);
 
__parser__(internal)
MK_EXTERN MK_STR MK_DECL MkSysStrNDup (
  MK_PARSER_fmtobj,
  MK_STRN const str,
  MK_SIZE const len
);
 
MK_EXTERN enum MkErrorE MK_DECL MkSysStrNCpy (
  MK_PARSER_fmtobj,
  MK_STR  const to,
  MK_STRN const from,
  MK_SIZE const len
);
 
 
__attribute__ ((alloc_size (3)))
__parser__(internal)
MK_EXTERN MK_PTR MK_DECL MkSysRealloc (
  MK_PARSER_fmtobj,
  MK_PTR const buf,
  size_t const size
);
 
__parser__(internal)
MK_EXTERN MK_PTR MK_DECL MkSysReCalloc (
  MK_PARSER_fmtobj,
  MK_PTR const buf,
  MK_NUM const oldnum,
  MK_NUM const addnum,
  size_t const size
);
 
__parser__(internal)
MK_EXTERN MK_PTR MK_DECL MkSysMemDup (
  MK_PARSER_fmtobj,
  MK_PTRN const blck,
  size_t const size
);
 
__parser__(internal)
MK_EXTERN MK_STRN_A MK_DECL MkSysStringArrayDup (
  MK_PARSER_fmtobj,
  MK_STRN_A const strA
);
 
__parser__(internal) void MkSysFree (MK_PTR pointer);
#define MkSysFree(pointer) \
  do { \
    if ( likely((pointer) != (NULL)) ) { \
      (*MkLal.SysFree)((MK_PTR)pointer); \
      (pointer) = (NULL); \
    } \
  } while (0)
 
__parser__(internal) void MkSysFreeNonNull (MK_PTR pointer);
#define MkSysFreeNonNull(pointer) (*MkLal.SysFree)((MK_PTR)pointer)
 
MK_EXTERN void MK_DECL MkSysFreeP(
  MK_PTR    data
);
 
MK_EXTERN void MK_DECL MkSysPrintTrace_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj,
  MK_I32        skip        __parser__(default=0),
  MK_I32  const num         __parser__(default=-1),
  MK_I32  const debug       __parser__(default=0),
  MK_STRN const callfunc    __parser__(default=F#FUNC),
  MK_I32  const lvl         __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
MK_EXTERN void MK_DECL MkSysPrintProcessMemoryMap_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj,
  MK_I32  const debug       __parser__(default=0),
  MK_STRN const callfunc    __parser__(default=F#FUNC),
  MK_I32  const lvl         __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
MK_EXTERN MK_STRN MK_DECL MkSysGetTrace_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj,
  MK_I32        skip        __parser__(default=0),
  MK_I32  const num         __parser__(default=-1),
  MK_I32  const debug       __parser__(default=0),
  MK_STRN const callfunc    __parser__(default=F#FUNC),
  MK_I32  const lvl         __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
__parser__(internal)
mk_inline enum MkErrorE MkSysWaitForProcess (
  MK_PARSER_fmtobj,
  MK_IDNT const id
) {
  return (*MkLal.MkSysWaitForProcessCB)(fmtobj, id);
};
 
__parser__(internal)
mk_inline enum MkErrorE MkSysWaitForThread (
  MK_PARSER_fmtobj,
  MK_IDNT const id
) {
  return (*MkLal.MkSysWaitForThreadCB)(fmtobj, id);
};
 
__parser__(internal)
mk_inline enum MkErrorE MkSysUSleep (
  MK_PARSER_fmtobj,
  useconds_t const    usec
) {
  return (*MkLal.SysUSleep)(fmtobj, usec);
};
 
mk_inline enum MkErrorE MkSysSleep (
  MK_PARSER_fmtobj,
  MK_I32  const sec
) {
  return (*MkLal.SysSleep)(fmtobj, (unsigned int)sec);
};
 
MK_NO_RETURN mk_inline void MkSysExit (
  MK_RT_ARGS
  int                   isThread,
  int                   num
) {
  (*MkLal.MkSysExitCB)(MK_RT_CALL isThread,num);
};
 
// [MkSysBasename-example]
MK_EXTERN MK_STR MK_DECL MkSysBasename_RT (
  MK_PARSER_RT
  MK_STRN const pathName,
  bool   const includeExtension
) MK_ATTR_RT_STATIC ;
// [MkSysBasename-example]
 
MK_EXTERN MK_STR MK_DECL MkSysDirname_RT (
  MK_PARSER_RT
  MK_STRN const pathName
) MK_ATTR_RT_STATIC;
 
MK_EXTERN MK_STR MK_DECL MkSysPrintF_RT (
  MK_PARSER_RT
  MK_STRN const format,
  ...
) MK_ATTR_RT_STATIC MK_RT_ATTR_FORMAT_1;
 
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkSysGetTimeOfDay (
  MK_PARSER_fmtobj,
  struct mk_timeval * tv_out,
  struct mk_timezone * tz_out
);
 
__parser__(internal,macro) bool MkSysStringSetNULL_R (MK_STRN const str);
#define MkSysStringSetNULL_R(_str) _str[0] = '\0'
 
__parser__(internal,macro) bool MkSysStringSet_R (MK_STRN const str, MK_STRN const other);
#define MkSysStringSet_R(_str,_val) strcpy(_str,_val)
 
__parser__(internal,macro) bool MkSysStringIsNULL_R (MK_STRN const str);
#define MkSysStringIsNULL_R(_str) (_str[0] == '\0')
 
mk_inline bool MkSysStringIsNULL (MK_STRN str) {
  return (str == NULL || MkSysStringIsNULL_R(str));
};
 
mk_inline bool MkSysStringIsNotNULL (MK_STRN str) {
  return (str != NULL && *str != '\0');
};
 
__parser__(internal,macro) bool MkSysStringIsEQUAL (MK_STRN const str, MK_STRN const other);
#define MkSysStringIsEQUAL(_str,_other) (strcmp(_str,_other) == 0)
 
__parser__(internal,macro) bool MkSysStringIsLenEQUAL (MK_STRN const str, MK_STRN const other, MK_SIZE const len);
#define MkSysStringIsLenEQUAL(_str,_other,_len) (strncmp(_str,_other,(size_t)_len) == 0)
 
mk_inline MK_STRN MkSysStringGet (MK_STRN str) {
  return MkSysStringIsNULL(str) ? NULL : str;
};
 
mk_inline MK_STRN MkSysStringGetNoNULL (MK_STRN str) {
  return str == NULL ? "" : str;
};
 
__parser__pop__;    // internal \}
 
__parser__(keep,doc-no)
MK_EXTERN MK_STRN MK_DECL MkSysHashSTR (
  MK_STRN key,                              
  MK_NUM  length __parser__(default=-1)     
) MK_ATTR_STATIC ;
 
__parser__(keep,doc-no)
MK_EXTERN MK_I32 MK_DECL MkSysHashI32 (
  MK_STRN key,                              
  MK_NUM  length __parser__(default=-1)     
) MK_ATTR_STATIC ;
 
__parser__(keep,doc-no)
MK_EXTERN enum MkErrorE MK_DECL MkSysKill (
  MK_PARSER_fmtobj,
  MK_I32 pid,
  MK_I32 signal
) MK_ATTR_INSTANCE ;
 
__parser__(keep,doc-no)
MK_EXTERN enum MkErrorE MK_DECL MkSysGetPid (
  MK_PARSER_fmtobj,
  MK_I32 * pid_out
) MK_ATTR_INSTANCE ;
 
__parser__(ignore)
typedef enum MkSysPipeHandlerE {
  MK_PIPE_KEEP    = 0,
  MK_PIPE_IGNORE  = 1
} MkSysPipeHandlerE;
 
__parser__(ignore)
MK_EXTERN void MK_DECL MkSysPipeHandler (
  MkSysPipeHandlerE keepPipe
) MK_ATTR_STATIC ;
 
// MkObjectC_Sys_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                      O B J E C T - A P I                        ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
__parser__global__(hide-rx=^Mk\w+Check\M);
__parser__global__(hide-rx=^MkObj[A-Z]);
__parser__global__(prefix2class:MkObj=MkObjectC);
 
 
  // TODO !! IMPORTANT INFO ABOUT CHECK !!
  // "MqCtxCheck(context)..." check of "context" create "MkDisasterEvent" after "fDecrSelf" etc…
  // Problem in PERL (and propably other too) after "fDecrSelf" the "context" becomes INVALID.
  // There are TWO phases of INVALID:
  // 1. INVALID but still readable -> "MqCtxCheck" works
  // 2. INVALID but NOT readable -> "MqCtxCheck" create "MkDisasterEvent"
  // It seems that "2." becomes more likely as "context" becomes bigger. "context" becomes bigger
  // if more prealloc space is used in "context". seems that if all references to ACTIVE memory is
  // gone an entire memory-page becomes "2." -> with other words:
  // -> It is not guaranteed that the "MqCtxCheck" technology will work.
 
#define __MkCheckTO(t,o)      (((*o).signature              & (*t).objmask) == (*t).objsig)
#define _MkCheckTO(t,o)       ((o) && __MkCheckTO((t),(o)))
#define __MkCheckO(cls,o)     (((*o).signature              & cls##_MASK) == cls##_SIGNATURE)
#define _MkCheckO(cls,o)      ((o) && __MkCheckO(cls,(o)))
#define __MkCheckX(cls,x)     __MkCheckO(cls,(cls##_X2obj(x)))
#define _MkCheckX(cls,x)      ((x) && __MkCheckO(cls,(cls##_X2obj(x))))
#define __MkCheckM(cls,m)     __MkCheckO(cls,((MK_OBJ)(m)))
#define _MkCheckM(cls,m)      ((m) && __MkCheckM(cls,m))
 
#define MkCheckNN(cls,x)      __MkCheckO(cls,(cls##_X2obj(x)))
 
#ifdef __SANITIZE_ADDRESS__
  //#define MkSanitizeCheck(_root,_m)   _root##_Check(_m)
  #define MkSanitizeCheck(_root,_m)   _MkCheckM(_root,_m)
  #define MkSanitizeCheckO(_root,_o)  _MkCheckO(_root,_o)
#else
  #define MkSanitizeCheck(_root,_m)   _MkCheckM(_root,_m)
  #define MkSanitizeCheckO(_root,_o)  _MkCheckO(_root,_o)
#endif
 
#define MkAssertO(cls,o)      assert(o==NULL?true:__MkCheckO(cls,o))    // NULL == true
#define MkAssertX(cls,x)      assert(x==NULL?true:__MkCheckX(cls,o))    // NULL == true
 
#define MkAssertCastM(cls,m)  ({MK_OBJ o=(MK_OBJ)(m);MkAssertO(cls,o);(cls##_type)(o);})
 
#define  toTT(_type)          (MkTYP(_type))
 
 
#define MK_NULL_SIGNATURE             0
 
struct MkObjectProtectS {
  bool          isLocal;
 
  MK_OBJ        prev;      
  MK_OBJ        next;      
};
 
struct MkObjectS {
  MK_SIG        signature;
  MK_HDL        netHdl;
  MK_I32        refCount;
  MK_PTR        self;
  MK_TYP        type;
  MK_PTR        env;
 
  //bool          onDelete;
 
  bool          deleteCallbackCalled;
 
  bool          selfCreated;
 
#if defined(META_USE_SELF_REFCOUNT)
  MK_I32        selfRefCount;
#endif
 
  MK_RT         objRt;
 
  MK_RTEXT      objRtExt;
 
  struct MkObjectProtectS obj_protect;
 
  // attention !! 
  //  an additional "attribute" have to be initialized in: MkObjInit
  //  also update : theKernel/cs/libmkkernel.cs
};
 
// BEGIN-MkObjectS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkObjectC_SIGNATURE            (0x59B3u<<16)
  #define MkObjectC_MASK                 (((1u<<16)-1)<<16)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkObjectC_X2obj(x)             (x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkObjectS MkObjectCR;
  __parser__(ignore) typedef const struct MkObjectS MkObjectCNR;
  #define MkObjectC_T                    (&MK_RT_REF._MkObjectC_T)
  #define MkObjectC_TT                   (MkTYP(MkObjectC_T))
  #define MkObjectST                     MkObjectC_T
  #define MkObjectSTT                    (MkTYP(MkObjectST))
  #define MkObjectC_type                 MK_OBJ
  #define MkObjectCT_X(instance)         ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkObjectCTT_X(instance)        (MkOBJ_R(instance).type)
  #define MkObjectCT_TT(typ)             ( (struct MkSuperTypeS *) (typ) )
  #define MkObjectC_NS                   MK
  #define MkObjectCTT                    MkObjectCTT
  #define MkObjectCT                     ( (struct MkSuperTypeS *) MkObjectCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkObjectC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkObjCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkObjectC,mng);
  }
 
  __parser__(class=MkObjectC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkObjCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkObjectC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkObjectC_Check(mng)           MkObjCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkObjectC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_OBJ MkObj(MK_MNG mng) {
    return (MkObjCheck(mng) ? (MK_OBJ)mng : NULL);
  }
 
  __parser__(class=MkObjectC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_OBJN MkObjN(MK_MNGN mng) {
    return (MkObjCheck(mng) ? (MK_OBJN)mng : NULL);
  }
 
  #define MkObjRaise(_obj) if (!_MkCheckX(MkObjectC,_obj)) { \
    MkErrorSetC_1E("'MkObjectC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkOBJ_R(x)        (*(x)).super.obj
  #define   MkOBJ(x)          (&MkOBJ_R(x))
 
 
  __parser__pop__;
// MkObjectC_Class_Define_C_API
 
// END-MkObjectS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// =========================================================================
// OVERLOAD
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkObjectC,no-rpc);
 
 
MK_ATTR_INSTANCE
mk_inline MK_HDL MK_DECL MkObjectHandleGetOfType ( MK_OBJ const obj ) {
  return ((MK_HDL)obj->signature);
}
 
#define MkObjectHandleGetOfType_1X(x)  MkObjectHandleGetOfType(MkOBJ(x))
 
MK_EXTERN bool MK_DECL MkObjectHandleExists ( 
  MK_OBJ const obj  __parser__(null-allowed)
) MK_ATTR_RT_INSTANCE ;
 
MK_EXTERN MK_HDL MK_DECL MkObjectHandleGetOr0 ( 
  MK_OBJ const obj  __parser__(null-allowed)
) MK_ATTR_RT_INSTANCE ;
 
__parser__pop__;
 
 
// =========================================================================
// BEGIN-MkObjectS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkObjectC);
 
MK_EXTERN MK_HDL MK_DECL MkObjectHandleGet_RT ( 
  MK_PARSER_RT
  MK_OBJ const obj  __parser__(null-allowed)
) MK_ATTR_RT_INSTANCE ;
 
#define MkObjectHandleGet_1X(x)  MkObjectHandleGet(x?MkOBJ(x):NULL)
 
MK_EXTERN MK_OBJ MkObjectHandleResolve_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
) MK_ATTR_RT_STATIC ;
 
#define MkObjectHandleResolve_e(netHdl) ({ \
  MK_HDL tmpHdl=netHdl; \
  MK_OBJ tmp; \
  if (tmpHdl==0) { \
    tmp=NULL; \
  } else { \
    tmp=MkObjectHandleResolve(tmpHdl); \
    if (tmp==NULL) { \
      MkErrorSetC_1_NULL("ERROR: 'MkObjectC' handle is 'NULL'"); \
      goto error; \
    }; \
  }; \
  tmp; \
})
 
MK_ATTR_RT_STATIC
MK_EXTERN void MkObjectHandleDeleteByNetHdl_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
);
 
MK_ATTR_RT_INSTANCE
MK_EXTERN void MkObjectHandleDelete_RT (
  MK_PARSER_RT
  MK_OBJ const netObj 
);
 
__parser__pop__;
 
// Class export & import
 
  __parser__(doc-group=_ignore_,doc-index=Class,doc-name=Misc,class=MkObjectC,null-return-allow)
  MK_ATTR_STATIC
  mk_inline MK_OBJ MkObjectGetNull ( void ) {
    return (MK_OBJ)MK_NULL;
  }
// MkObjectC - Misc - function
 
// MkObjectC_Class_C_API
 
// END-MkObjectS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
typedef MK_OBJ  (*MkConstructorF)   ( MK_RT_ARGS MK_TYP type, MK_PTR nat, MK_PTR lnk);
typedef void    (*MkDestructorF)    ( MK_RT_ARGS MK_OBJ const obj);
typedef MK_OBJ  (*MkDupF)           ( MK_RT_ARGS MK_OBJ const obj);
typedef MK_OBJ  (*MkDup2F)          ( MK_RT_ARGS MK_OBJ const obj, MK_STRN const ident);
typedef MK_OBJ  (*MkMergeF)         ( MK_RT_ARGS MK_OBJ const obj);
typedef MK_OBJ  (*MkCopyF)          ( MK_RT_ARGS MK_OBJ const obj, MK_OBJN const src);
typedef MK_OBJ  (*MkResetF)         ( MK_RT_ARGS MK_OBJ const obj);
__parser__(flags=public-internal)
typedef MK_PTR  (*MkSelfCreateF)    ( MK_RT_ARGS MK_OBJ const obj, MK_PTR const env);
__parser__(flags=public-internal)
typedef void    (*MkSelfDeleteF)    ( MK_RT_ARGS MK_PTR self, MK_PTR const env);
__parser__(flags=public-internal)
typedef void    (*MkSelfUnlinkF)    ( MK_RT_ARGS MK_PTR self, MK_PTR const env);
typedef void    (*MkLogF)           ( MK_RT_ARGS 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_ARGS MK_OBJN const obj);
typedef MK_PTR  (*MkAllocCreateFLT)   ( MK_RT_ARGS MK_TYP const type);
typedef void    (*MkAllocDeleteF)   ( MK_RT_ARGS MK_TYP const type, MK_PTR ptr);
typedef void    (*MkTypeInitF)      ( MK_RT_ARGS MK_TYP const type);
typedef bool    (*MkLogFormatF)     ( MK_RT_ARGS char* header, MK_SIZE const headerSize, MK_OBJN const obj, 
                                        MK_STRN const caller, MK_I32 const debug, MK_STRN const fmt);
 
__parser__(ignore)
struct MkAllocDefS {
  MK_PTR            alloc_data;         
  MkAllocCreateFLT  alloc_createF;      
  MkAllocDeleteF    alloc_deleteF;      
};
 
 
// MkObjectC_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                     T Y P E - A P I                             ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
__parser__(internal)
struct MkTypeS {
  // BEGIN-MkTypeS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkTypeS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  #define MkTypeS_name_size 32
  MK_STRB type_name[MkTypeS_name_size];  
  MK_SIG              objsig;       
  MK_SIG              objmask;      
  bool                noSelf;       
  MK_TYP              base;         
  size_t              objsize;      
  size_t              typsize;      
 
  MK_I32              type_id;      
  MkTypeInitF         type_init;    
 
  // slots
  MkToStringF         toString;     
  MkLogF              log;          
  MkConstructorF      constructor;  
  MkDestructorF       destructor;   
  MkDupF              dup;          
  MkDup2F             dup2;         
  MkMergeF            merge;        
  MkCopyF             copy;         
  MkResetF            reset;        
  MkSelfCreateF       selfCreate;   
  MkSelfDeleteF       selfDelete;   
  MkSelfUnlinkF       selfUnlink;   
  MkLogFormatF        fLogFormat;   
 
  MK_I32              delCbCnt;     
 
  struct MkAllocDefS  objalloc;     
  MK_OBJ              instances;   
};
 
// BEGIN-MkTypeS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkTypeC_SIGNATURE              (MkObjectC_SIGNATURE ^ (10u<<10))
  #define MkTypeC_MASK                   (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkTypeC_X2typ(x)               (x)
  #define MkTypeC_X2obj(x)               MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkTypeS MkTypeCR;
  __parser__(ignore) typedef const struct MkTypeS MkTypeCNR;
  #define MkTypeSTT                      (&MK_RT_REF._MkTypeC_TT)
  #define MkTypeC_TT                     (&MK_RT_REF._MkTypeC_TT)
  #define MkTypeC_type                   MK_TYP
  #define MkTypeCT_X(instance)           ( (struct MkTypeS *) (MkOBJ_R(instance).type) )
  #define MkTypeCTT_X(instance)          (MkOBJ_R(instance).type)
  #define MkTypeCT_TT(typ)               ( (struct MkTypeS *) (typ) )
  #define MkTypeC_NS                     MK
  #define MkTypeCTT                      MkTypeCTT
  #define MkTypeCT                       ( (struct MkTypeS *) MkTypeCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkTypeC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkTypCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkTypeC,mng);
  }
 
  __parser__(class=MkTypeC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkTypCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkTypeC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkTypeC_Check(mng)             MkTypCheck(mng)
 
 
  __parser__pop__;
// MkTypeC_Class_Define_C_API
 
// END-MkTypeS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(class=MkObjectC,internal,static)
mk_inline MK_TYP MkTyp(const MK_MNG mng) {
  if (!MkObjCheck(mng)) return NULL;
  MK_OBJ obj = (MK_OBJ) mng;
  if (MkTypCheck(obj)) return (MK_TYP)obj;
  MK_TYP typ = obj->type;
  if (MkTypCheck(typ)) return typ;
  return NULL;
}
 
__parser__(ignore)
mk_inline MK_TYPN MkTypN(const MK_MNGN mng) {
  if (!MkObjCheck(mng)) return NULL;
  MK_OBJ obj = (MK_OBJ) mng;
  if (MkTypCheck(obj)) return (MK_TYPN)obj;
  MK_TYPN typ = obj->type;
  if (MkTypCheck(typ)) return typ;
  return NULL;
}
 
#define   MkTYP_R(x)        (*(x)).super.typ
#define   MkTYP(x)          (&MkTYP_R(x))
 
__parser__(ignore)
struct MkSuperTypeS {
  // BEGIN-MkSuperTypeS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkTypeS              typ;          // instance-base MkTypeS
  } super;
 
  // END-MkSuperTypeS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
};
 
// BEGIN-MkSuperTypeS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkSuperTypeC_SIGNATURE         (MkTypeC_SIGNATURE ^ (1u<<6))
  #define MkSuperTypeC_MASK              (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkSuperTypeC_X2typ(x)          MkTYP(x)
  #define MkSuperTypeC_X2obj(x)          MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkSuperTypeS MkSuperTypeCR;
  __parser__(ignore) typedef const struct MkSuperTypeS MkSuperTypeCNR;
  #define MkSuperTypeSTT                 (&MK_RT_REF._MkSuperTypeC_TT)
  #define MkSuperTypeC_TT                (&MK_RT_REF._MkSuperTypeC_TT)
  #define MkSuperTypeCT_X(instance)      ( (struct MkTypeS *) (MkOBJ_R(instance).type) )
  #define MkSuperTypeCTT_X(instance)     (MkOBJ_R(instance).type)
  #define MkSuperTypeCT_TT(typ)          ( (struct MkTypeS *) (typ) )
  #define MkSuperTypeC_NS                MK
  #define MkSuperTypeCTT                 MkSuperTypeCTT
  #define MkSuperTypeCT                  ( (struct MkTypeS *) MkSuperTypeCTT )
 
 
  __parser__pop__;
// MkSuperTypeC_Class_Define_C_API
 
// END-MkSuperTypeS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(internal)
MK_EXTERN MK_PTR MK_DECL MkTypeSlotResolveP(MK_RT_ARGS MK_TYPN const type, size_t const offset, bool const force);
 
#define MkTypeSlotResolve(_tt,fptr,force)  ({                                                            \
  MK_TYP tt = (_tt) ; /* _tt my be long */                                                               \
  tt == NULL ? NULL : /* type not valid */                                                               \
    !force && tt->fptr == (MK_PTR) 0x1 ? NULL : /* already resolved, NOT found */                        \
      tt->fptr > (typeof(tt->fptr)) 0x1 ? tt->fptr : /* already resolved, NOT NULL, found */             \
        tt == MkTypeSTT ? NULL : /* already at the ROOT of the type */                                   \
          (typeof(tt->fptr)) MkTypeSlotResolveP(MK_RT_CALL tt, offsetof(struct MkTypeS, fptr), force);   \
})                                                                                                       \
 
#define MkTypeSlotCall(_tt,fptr,...) do {                           \
  typeof((_tt)->fptr) slot = MkTypeSlotResolve((_tt),fptr,false);   \
  if (slot) (*slot)(MK_RT_CALL __VA_ARGS__);                        \
} while (false)
 
// MkTypeC_C_API
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=TOR);
 
#if defined(META_USE_SELF_REFCOUNT)
  // [MkObjInit2]
  #define MkObjInit2(rtmkV,rtExtV,sigV,typeV,refCountV,isLocalV)    \
    (struct MkObjectS) {                                            \
      .signature    = sigV,                                         \
      .refCount     = refCountV,                                    \
      .self         = NULL,                                         \
      .type         = typeV,                                        \
      .env          = NULL,                                         \
      .selfCreated  = false,                                        \
      .selfRefCount = 0,                                            \
      .objRt        = rtmkV,                                        \
      .objRtExt     = rtExtV,                                       \
      .obj_protect  = {                                             \
        .isLocal      = isLocalV,                                   \
        .prev         = NULL,                                       \
        .next         = NULL,                                       \
      },                                                            \
    }
  // [MkObjInit2]
#else
  #define MkObjInit2(rtmkV,rtExtV,sigV,typeV,refCountV,isLocalV)    \
    (struct MkObjectS) {                                            \
      .signature    = sigV,                                         \
      .refCount     = refCountV,                                    \
      .self         = NULL,                                         \
      .type         = typeV,                                        \
      .env          = NULL,                                         \
      .selfCreated  = false,                                        \
      .objRt        = rtmkV,                                        \
      .objRtExt     = rtExtV,                                       \
      .obj_protect  = {                                             \
        .isLocal      = isLocalV,                                   \
        .prev         = NULL,                                       \
        .next         = NULL,                                       \
      },                                                            \
    }
#endif
 
#define MkObjInit(rtmkV,rtExtV,cls,refCountV,isLocalV) \
  MkObjInit2(rtmkV,rtExtV,cls##_SIGNATURE,cls##_TT,refCountV,isLocalV)
 
// [MkObjInitFromType]
#define MkObjInitFromType(typeV,isLocalV) \
  MkObjInit2(MK_RT_PTR, NULL, (*typeV).objsig, typeV,  0, isLocalV)
// [MkObjInitFromType]
 
#define MkObjInitFromInstance(instV) \
  MkObjInit2(MK_RT_PTR, NULL, MkOBJ_R(instV).type->objsig, MkOBJ_R(instV).type,  0, false)
 
__parser__(constructor)
MK_EXTERN MK_OBJ MK_DECL MkObjDup_RT (
  MK_PARSER_RT
  MK_OBJ const srcobj
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_OBJ MK_DECL MkObjDup2_RT (
  MK_PARSER_RT
  MK_OBJ const srcmng,
  MK_STRN const ident
) MK_ATTR_RT_INSTANCE;
 
__parser__(constructor)
MK_EXTERN MK_OBJ MK_DECL MkObjMerge_RT (
  MK_PARSER_RT
  MK_OBJ const obj
) MK_ATTR_RT_INSTANCE ;
 
__parser__(constructor)
MK_EXTERN MK_OBJ MK_DECL MkObjCreate_RT (
  MK_PARSER_RT
  MK_TYP        type __parser__(internal,default=NULL),
  MK_PTR        nat,
  MK_PTR        lnk
) MK_ATTR_RT_STATIC ;
 
// *******************************************************************************
// PUBLIC object API
// *******************************************************************************
 
__parser__(destructor,keep-destr)
MK_EXTERN void MK_DECL MkObjectDelete_RT (
  MK_PARSER_RT
  MK_OBJ obj
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectDelete_NULL(obj)  MkObjectDeleteToNull(MkObjectDelete_RT,MK,obj)
#define MkObjectDelete_NULL_X(x)  MkObjectDeleteToNull_X(MkObjectDelete_RT,MK,x)
#define MkObjectDelete_1X(x)      MkObjectDeleteToNull_X(MkObjectDelete_RT,MK,x)
 
#define MkObjectDeleteToNull(fct,NS,x)   if (x) { fct (NS##_RT_CALL x);        (x) = NULL ; }
#define MkObjectDeleteToNull_X(fct,NS,x) if (x) { fct (NS##_RT_CALL MkOBJ(x)); (x) = NULL ; }
 
__parser__(destructor,lng-destr,lng-dispose)
MK_EXTERN void MK_DECL MkObjectDispose_RT (
  MK_PARSER_RT
  MK_OBJ obj
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectDispose_NULL(obj)   MkObjectDeleteToNull(MkObjectDispose_RT,MK,obj)
#define MkObjectDispose_NULL_X(x)   MkObjectDeleteToNull_X(MkObjectDispose_RT,MK,x)
#define MkObjectDispose_1X(x)       MkObjectDispose(MkOBJ(x))
 
#define MkObjectDeleteCallF_CHECK do { \
  assert (__data__ != NULL); \
} while (0)
 
// [MkObjectDeleteCallF]
#define MkObjectDeleteCallF_ARGS             \
  MK_RT_ARGS                                 \
  MK_OBJN const obj __parser__(internal),    \
  MK_STRN const typeName,                    \
  MK_HDL  const typeHdl,                     \
  MK_HDL  const objHdl,                      \
  MK_CBP  const __data__                     \
 
#define MkObjectDeleteCallF_CALL  MK_RT_CALL obj, __data__
 
__parser__(flags=public-internal)
typedef enum MkErrorE ( MK_DECL *MkObjectDeleteCallF) ( MkObjectDeleteCallF_ARGS ) ;
 
#define MkObjectDeleteFreeF_ARGS  MK_RT_ARGS MK_CBP *dataP __parser__(inout)
 
__parser__(flags=public-internal)
typedef void ( MK_DECL *MkObjectDeleteFreeF) ( MkObjectDeleteFreeF_ARGS ) ;
 
__parser__(class=MkObjectC,callback-name=ObjectDelete,callback-null)
MK_EXTERN enum MkErrorE MK_DECL MkObjectDeleteCallbackSetup_RT (
  MK_PARSER_RT
  MK_STRN               ident ,
  MkObjectDeleteCallF   fCall       __parser__(callback-call),
  MK_CBP                callback    __parser__(callback-data),
  MkObjectDeleteFreeF   fFree       __parser__(callback-free),
  MK_STRN               filter      __parser__(default=NULL)
) MK_ATTR_RT_STATIC ;
// [MkObjectDeleteCallF]
 
__parser__(class=MkObjectC)
MK_EXTERN void MK_DECL MkObjectDeleteCallbackCleanup_RT (
  MK_PARSER_RT
  MK_STRN               ident
) MK_ATTR_RT_STATIC ;
 
__parser__pop__; // TOR
 
// MkObjectC_TOR_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                        O B J - A P I                            ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
// ***********************************************************************************************
 
 
MK_EXTERN MK_OBJ MK_DECL MkObjCopy_RT (
  MK_PARSER_RT
  MK_OBJ  const tgtmng,
  MK_OBJN const srcmng
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_OBJ MK_DECL MkObjReset_RT (
  MK_PARSER_RT
  MK_OBJ const obj
) MK_ATTR_RT_INSTANCE;
 
// ****************************************************************************************************
 
 
__parser__global__(hide-rx=^MkRef);
__parser__global__(pattern2prefix:MkRef=MkObj);
 
#define MkRefLOCK           999999
 
__parser__(static)
MK_ATTR_STATIC
mk_inline void MkRefIncr ( MK_OBJ obj ) {
  if (obj) ++(*obj).refCount;
}
 
#define MkRefIncr_1X(x)      MkRefIncr(MkOBJ(x))
#define MkRefIncr_1M(m)      MkRefIncr(MkObj(m))
 
#define MkRefIncr_FX(x)     MkRefIncr(MkOBJ(x))
 
__parser__(static)
MK_EXTERN void MkRefDecr_RT (
  MK_PARSER_RT
  MK_OBJ obj
) MK_ATTR_RT_INSTANCE;
 
#define MkRefDecr_O(o)        do { MkRefDecr_RT(MK_RT_CALL o); o=NULL; } while (0)
#define MkRefDecr_X(x)        do { MkRefDecr_RT(MK_RT_CALL MkOBJ(x)); x=NULL; } while (0)
#define MkRefDecr_X_NULL(x)   do { MkRefDecr_RT(MK_RT_NULL MkOBJ(x)); x=NULL; } while (0)
#define MkRefDecr_M(m)        do { MkRefDecr_RT(MK_RT_CALL MkObj(m)); m=NULL; } while (0)
#define MkRefDecr_M_NULL(m)   do { MkRefDecr_RT(MK_RT_NULL MkObj(m)); m=NULL; } while (0)
 
#define MkRefDecr_FX(x)       do { --(MkOBJ_R(x).refCount); } while(0)
 
MK_ATTR_INSTANCE
mk_inline void MkRefIncrSelf( MK_OBJ const obj, MK_PTR const self, MK_PTR const env) {
  MK_INSTANCE_HDL(obj);
  obj->refCount++;
  obj->self = self;
  obj->env  = env;
}
 
#define MkRefIncrSelf_2X(x,s) MkRefIncrSelf(MkOBJ(x),s)
 
MK_EXTERN MK_OBJ MkRefDecrWithoutSelf_RT (
  MK_PARSER_RT
  MK_OBJ const obj
) MK_ATTR_RT_INSTANCE;
 
//  2. \b unlink the \e SELF from \e META using the \RMkRefDecrWithoutSelf call
MK_EXTERN MK_OBJ MkRefDecrWithUnlinkSelf_RT (
  MK_PARSER_RT
  MK_OBJ const obj
) MK_ATTR_RT_INSTANCE;
 
__parser__(keep,doc-no)
MK_ATTR_INSTANCE
mk_inline MK_I32 MkRefGet ( MK_OBJ const obj ) {
  MK_INSTANCE_HDL(obj);
  return (*obj).refCount;
}
 
#define MkRefGet_1X(x)        MkRefGet(MkOBJ(x))
 
MK_ATTR_INSTANCE
mk_inline MK_I32 MkRefLock ( MK_OBJ const obj ) {
  MK_INSTANCE_HDL(obj);
  return (*obj).refCount=MkRefLOCK;
}
#define MkRefLock_1X(x)       MkRefLock(MkOBJ(x))
 
MK_ATTR_INSTANCE
mk_inline bool MkRefIsLocked ( MK_OBJ const obj ) {
  MK_INSTANCE_HDL(obj);
  return (*obj).refCount >= MkRefLOCK;
}
#define MkRefIsLocked_1X(x)   MkRefIsLocked(MkOBJ(x))
 
#define MkRefSet(target,source) ({ \
  if (target != source) { \
    typeof(target) targetSave=target; \
    target = source;\
    MkRefDecr_X(targetSave);\
    MkRefIncr_1X(target);\
  } \
  target;\
})
 
MK_EXTERN MK_NUM MkRefCidN_RT( MK_PARSER_RT_ONLY ) MK_ATTR_RT_STATIC;
 
#define MkRefCidN_NULL()  MkRefCidN_RT(MK_RT_CALL_NULL_ONLY)
 
// MkRef…
 
// *******************************************************************************
 
__parser__global__(hide-rx=^MkSelf);
__parser__global__(pattern2prefix:MkSelf=MkObj);
 
 
typedef void    (*MkSelfIncrF)      ( MK_RT_ARGS MK_PTR self, MK_PTR const env);
typedef void    (*MkSelfDecrF)      ( MK_RT_ARGS MK_PTR self, MK_PTR const env);
 
MK_ATTR_INSTANCE
mk_inline void MK_DECL MkSelfSet ( MK_OBJ const obj, MK_PTR const self, MK_PTR const env ) {
  MK_INSTANCE_HDL(obj);
  obj->env = env;
  obj->self = (obj->type->noSelf ? NULL : self);
}
 
#define MkSelfSet_3X(x,self,env) MkSelfSet(MkOBJ(x),self,env)
 
MK_ATTR_INSTANCE
mk_inline MK_PTR MK_DECL MkSelfGet ( MK_OBJ const obj ) {
  // BUG FIX - 1 mar 2023: remove nonnull on obj because C# require this
  return obj ? obj->self : NULL;
}
 
#define MkSelfGet_1X(x) MkSelfGet(MkOBJ(x))
 
MK_ATTR_RT_INSTANCE MK_ATTR_HOT
mk_inline enum MkErrorE MK_DECL MkSelfNew_RT (
  MK_PARSER_RT
  MK_OBJ  obj         __parser__(null-allowed),
  MK_PTR  *self_out,
  MK_PTR  const env
);
 
#define MkSelfNew_3X(x,self_out,env) MkSelfNew(MkOBJ(x),self_out,env)
 
MK_ATTR_RT_INSTANCE
MK_EXTERN MK_PTR MK_DECL MkSelfCreate_RT (
  MK_PARSER_RT
  MK_OBJ const obj,
  MK_PTR const env
);
 
#define MkSelfCreate_2X(x,env) MkSelfCreate(MkOBJ(x),env)
 
__parser__(static)
MK_EXTERN bool MK_DECL MkSelfDelete_RT (
  MK_PARSER_RT
  MK_OBJ const obj
) MK_ATTR_RT_INSTANCE;
 
#define MkSelfDelete_1X(x) MkSelfDelete_RT(MK_RT_CALL MkOBJ(x))
 
__parser__(static)
MK_EXTERN bool MK_DECL MkSelfDeleteForce_RT (
  MK_PARSER_RT
  MK_OBJ obj
) MK_ATTR_RT_INSTANCE;
 
#define MkSelfDeleteForce_1X(x) MkSelfDeleteForce(MkOBJ(x))
 
__parser__(static)
MK_EXTERN void MK_DECL MkSelfUnlink_RT (
  MK_PARSER_RT
  MK_OBJ obj
) MK_ATTR_RT_INSTANCE;
 
#define MkSelfUnlink_1X(x) MkSelfUnlink(MkOBJ(x))
 
MK_ATTR_INSTANCE
mk_inline bool MkSelfExists ( MK_OBJN obj ) {
  MK_INSTANCE_HDL(obj);
  return obj->self != NULL;
}
 
#define MkSelfExists_1X(x) MkSelExists(MkOBJ(x))
 
 
// addtogroup MkObjectC_Obj_C_API
 
// ****************************************************************************************************
 
 
//__parser__global__(hide-rx=^MkType);
//__parser__global__(prefix2attribute=MkType@internal);
//__parser__global__(prefix2attribute=MkType@class=MkTypeC);
 
__parser__push__(internal,class=MkTypeC); // \{ internal
 
__parser__push__(doc-group=TOR);
 
__parser__(macro)
MK_TYP MkTypeCreate ( MK_MACRO_TYP const clsV, MK_MACRO_TYP const basicV, MK_STRN const identV);
// [MkTypeCreate]
#define MkTypeCreate(clsV, basicV, identV) ({     \
  MK_TYP ret = MkTypeDup2(basicV ## _TT,identV);  \
  ret->objsig = clsV ## _SIGNATURE;               \
  ret->objmask = clsV ## _MASK;                   \
  ret->objsize = sizeof(clsV##R);                 \
  ret ;                                           \
})
// [MkTypeCreate]
 
MK_EXTERN MK_TYP MkTypeDup2_RT (
  MK_PARSER_RT
  MK_TYPN const typ,
  MK_STRN const ident
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_OBJ MK_DECL MkTypeAlloc_RT (
  MK_PARSER_RT
  MK_TYPN const  typ
) MK_ATTR_RT_INSTANCE ;
 
MK_EXTERN MK_TYP MK_DECL MkTypeResolve_RT (
  MK_PARSER_RT
  MK_TYPN const typ
) MK_ATTR_RT_INSTANCE ;
 
MK_EXTERN void MK_DECL MkTypeDelete_RT (
  MK_PARSER_RT
  MK_TYP const typ
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__;
 
// MkTypeC_C_TOR_C_API
 
__parser__(const,class-overload=MkObjectLog)
MK_EXTERN void MK_DECL MkTypeLog_RT (
  MK_PARSER_RT
  MK_TYPN const  typ       ,
  MK_PARSER_fmtobj         ,
  MK_DBG  const  debug     __parser__(default=0),
  MK_STRN const  callfunc  __parser__(default=F#FUNC),
  MK_I32  const  lvl       __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
 
#if META_TYPE_DEBUG == 0
  #define MkTypeLoop(_cls, _var) \
    for (_cls##_type _var = (_cls##_type)_cls##_TT->instances; _var != NULL; \
      _var = (_cls##_type)_cls##_X2obj(_var)->obj_protect.next)
#else
  #define MkTypeLoop(_cls, _var) \
    bool _var##_firstB = true; \
    _cls##_type _var##_first = (_cls##_type)_cls##_TT->instances; \
    for ( \
      _cls##_type _var = _var##_first; \
        ({  if (!_var##_firstB && _var == _var##_first) {  \
              MkPanicV_2M(_var,"[MkTypeLoop] INTERNAL ERROR: found 'circle' in 'MkTypeC=%s'", _var->type_name); \
            } ; _var##_firstB = false; _var; }); \
          _var = (_cls##_type)_cls##_X2obj(_var)->obj_protect.next \
    )
#endif
 
 
__parser__pop__;  // \} 
// internal
 
// addtogroup MkTypeC_C_API
 
 
__parser__(internal,doc-group=Misc)
MK_EXTERN MK_BFL MK_DECL MkKernelGetTypeList_RT (
  MK_PARSER_RT_ONLY
) MK_ATTR_RT_STATIC;
 
 
// ##################################################################################
 
MK_EXTERN MK_STRN const MK_DECL MkObjectToName_RT (
  MK_PARSER_RT
  MK_OBJN const obj
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectToName_1X(x) MkObjectToName(MkOBJ(x))
 
MK_EXTERN MK_STRN MK_DECL MkObjectToNameOfType_RT (
  MK_PARSER_RT
  MK_OBJN const obj
) MK_ATTR_RT_INSTANCE;
 
//2021.03.01 ao → #define MkObjectToNameOfType(o) MkObjectToNameOfType((MK_OBJ)(o))
#define MkObjectToNameOfType_1X(x) MkObjectToNameOfType(MkOBJ(x))
 
__parser__(template-overload,template-in-c)
MK_EXTERN MK_STRN MK_DECL MkObjectToNameOfClass_RT (
  MK_PARSER_RT
  MK_OBJ const obj
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectToNameOfClass_1X(x) MkObjectToNameOfClass_RT(MK_RT_CALL MkOBJ(x))
 
MK_EXTERN MK_STRN MK_DECL MkObjectToString_RT (
  MK_PARSER_RT
  MK_OBJN const inst    __parser__(null-allowed)
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectToString_1X(x) MkObjectToString(x?MkOBJ(x):NULL)
#define MkObjectToString_1M(m) MkObjectToString(m?MkObjN(m):NULL)
 
MK_ATTR_INSTANCE
mk_inline bool MkObjectIsNull ( 
  MK_OBJ const obj  __parser__(null-allowed)
) {
  return (obj == MK_NULL);
}
 
// MkObjectC_Misc_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                        L O G - A P I                            ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
__parser__push__(doc-group=Log);
 
__parser__(no-type-extension)
MK_EXTERN void MK_DECL MkLogC_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj          ,
  MK_STRN const  message    ,
  MK_DBG  const  debug      __parser__(default=0),
  MK_STRN const  callfunc   __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
#define MkLogC_4X(x,message,debug,callfunc)       MkLogC(MkOBJ(x),message,debug,callfunc)
#define MkLogC_3X(x,message,debug)                MkLogC_3(MkOBJ(x),message,debug)
#define MkLogC_2X(x,message)                      MkLogC_2(MkOBJ(x),message)
#define MkLogW(x,callfunc,_debug,message)         MkLogC(MkOBJ(x),message,_debug,callfunc)
 
MK_EXTERN void MK_DECL MkLogV_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj        ,
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_DBG        debug     __parser__(default=0),
  MK_FST  const printfmt,
  ...
) MK_ATTR_RT_INSTANCE MK_RT_ATTR_FORMAT_4;
 
#define MkLogV_lvl(x,debug,printfmt,...)          MkLogV(MkOBJ(x),__func__,debug,printfmt,__VA_ARGS__)
 
#define MkLogV_4M(x,callfunc,debug,printfmt,...)  MkLogV(MkObjN(x),callfunc,debug,printfmt,__VA_ARGS__)
#define MkLogV_4X(x,callfunc,debug,printfmt,...)  MkLogV(MkOBJ(x),callfunc,debug,printfmt,__VA_ARGS__)
#define MkLogV_3X(x,callfunc,printfmt,...)        MkLogV_3(MkOBJ(x),callfunc,printfmt,__VA_ARGS__)
#define MkLogV_2X(x,printfmt,...)                 MkLogV_2(MkOBJ(x),printfmt,__VA_ARGS__)
 
MK_EXTERN void MK_DECL MkLogVL_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj        ,
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_DBG        debug     __parser__(default=0),
  MK_FST  const printfmt,
  va_list       var_list
) MK_ATTR_RT_INSTANCE;
 
#define MkLogVL_5X(fmtobj,callfunc,debug,printfmt,var_list) \
          MkLogVL(MkOBJ(fmtobj),callfunc,debug,printfmt,var_list)
 
#if defined(META_DISABLE_LOG)
  # define MkDCheck(_debug)
  # define MkDLogC(x,_debug,str)
  # define MkDLogV(x,_debug,printfmt,...)
#else
 
  # define MkDDInit  const MK_I32 __dbg = MK_RT_REF.debug
  # define MkDDInitNum(n)  const MK_I32 __dbg = n
 
#   define MkDCheck(_debug) if (unlikely(MK_RT_REF.debug >= _debug))
#   define MkDDCheck(_debug) if (unlikely(__dbg >= _debug))
 
#   define MkDLogC_O(fmtobj,_debug,str) \
      if (unlikely(MK_RT_REF.debug >= _debug)) MkLogC(fmtobj,str,_debug,__func__)
 
#   define MkDLogC(x,_debug,str)   MkDLogC_O(MkOBJ(x),_debug,str)
 
#   define MkDDLogC(x,_debug,str) \
      if (unlikely(__dbg >= _debug)) MkLogC_4X(x,str,_debug,__func__)
 
#   define MkDLogV_O(fmtobj,_debug,printfmt,...) \
      if (unlikely(MK_RT_REF.debug >= _debug)) MkLogV(fmtobj,__func__,_debug,printfmt,__VA_ARGS__)
 
#   define MkDLogV(x,_debug,printfmt,...)  MkDLogV_O(MkOBJ(x),_debug,printfmt,__VA_ARGS__)
 
#   define MkDDLogV(fmtobj,_debug,printfmt,...) \
      if (unlikely(__dbg >= _debug)) MkLogV_4M(fmtobj,__func__,_debug,printfmt,__VA_ARGS__)
 
#endif
 
MK_EXTERN void MK_DECL MkLogHEX_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj        ,
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MkBinaryR const data
) MK_ATTR_RT_INSTANCE;
 
#define MkLogHEX_4X(fmtobj,callfunc,data,len)  MkLogHEX_RT(MkOBJ(fmtobj),callfunc,data,len)
 
__parser__(const)
MK_EXTERN void MK_DECL MkObjectLogSimple_RT (
  MK_PARSER_RT
  MK_OBJN const obj       ,
  MK_PARSER_fmtobj        ,
  MK_DBG  const debug     __parser__(default=0),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectLogSimple_1X(x)    MkObjectLogSimple(MkOBJ(x),NULL,0,__func__,0)
 
__parser__(const)
MK_EXTERN void MK_DECL MkObjectLogDetail_RT (
  MK_PARSER_RT
  MK_OBJN const obj,
  MK_PARSER_fmtobj        ,
  MK_DBG  const debug     __parser__(default=0),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectLogDetail_1X(x)   MkObjectLogDetail(MkOBJ(x),NULL,0,__func__,0)
#define MkObjectLogDetail_1M(m)   MkObjectLogDetail(MkObj(m),NULL,0,__func__,0)
 
MK_EXTERN void MK_DECL MkObjectLog_RT (
  MK_PARSER_RT
  MK_OBJN const obj,
  MK_PARSER_fmtobj        ,
  MK_DBG  const debug     __parser__(default=0),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectLog_1X(x)   MkObjectLog(MkOBJ(x),NULL,0,__func__,0)
 
__parser__pop__;
 
// MkObjectC_Log_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                        D B G - A P I                            ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
__parser__global__(prefix2class:MkDbg=MkObjectC);
 
__parser__(no-type-extension)
MK_EXTERN void MK_DECL MkDbgL_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj          ,
  MK_STRN const  message    ,
  MK_DBG  const  debug      __parser__(default=0),
  MK_STRN const  callfunc   __parser__(default=F#FUNC),
  MK_I32  const  lvl        __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
#define MkDbgL_2M(x,message)  MkDbgL(MkObj(x),message,0,__func__,-1)
 
__parser__(no-type-extension,template-overload)
MK_EXTERN enum MkErrorE MK_DECL MkDbgDump_RT (
  MK_PARSER_RT
  MK_OBJN const  obj,
  MK_STRN const  message   __parser__(default=S#"var"),
  MK_STRN const  callfunc  __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
#define MkDbgDump_2M(x,message) MkDbgDump_2(MkObj(x),message)
 
MK_EXTERN void MK_DECL MkDbgM_RT (
  MK_PARSER_RT
  MK_STRN const  message   ,
  MK_DBG  const  debug     __parser__(default=0),
  MK_STRN const  callfunc  __parser__(default=F#FUNC),
  MK_I32  const  lvl       __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
MK_EXTERN void MK_DECL MkDbgSTACK_RT (
  MK_PARSER_RT
  MK_PARSER_fmtobj         ,
  MK_I32  const  skip      __parser__(default=0),
  MK_I32  const  num       __parser__(default=-1),
  MK_STRN const  callfunc  __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
#define MkDbgSTACK_3X(x,num,callfunc)  MkDbgSTACK_3(MkOBJ(x),num,callfunc)
 
__parser__(no-type-extension)
MK_EXTERN void MK_DECL MkDbgO_RT (
  MK_PARSER_RT
  MK_OBJN const obj,
  MK_STRN const callfunc  __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
#define MkDbgO_2X(x,callfunc)   MkDbgO(MkObj(x),callfunc)
#define MkDbgO_1X(x)            MkDbgO_2X(x,__func__)
#define MkDbgO_1O(x)            MkDbgO(x,__func__)
 
__parser__(no-type-extension)
MK_EXTERN void MK_DECL MkDbgLogC_RT (
  MK_PARSER_RT
  MK_OBJN const obj,
  MK_STRN const callfunc  __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
#define MkDbgLogC_2X(x,callfunc) MkDbgLogC_2(MkOBJ(x),callfunc)
 
// MkObjectC_Dbg_C_API
 
/* MARK_B ################################################################ */
/* ###                                                                 ### */
/* ###                     B U F F E R - A P I                         ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
#define MkBufferS_ils_size (0)
 
// [MkBufferS_example]
struct MkBufferS {
  // BEGIN-MkBufferS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkBufferS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  struct {
    MK_NUM cursize;                     
    enum MkTypeE type;                  
  } var;                                
  // instance storage
  struct {
    union MkBufferU first;              
    MK_NUM  size;                       
    bool    doBufferFree;               
  } storage;                            
  struct ilsS {
    MK_NUM  size;                       
    MK_NUM  offset;                     
  } ils;                                
  MK_BINB ils_data[MkBufferS_ils_size]; 
};
 
// BEGIN-MkBufferS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBufferC_SIGNATURE            (MkObjectC_SIGNATURE ^ (1u<<10))
  #define MkBufferC_MASK                 (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBufferC_X2buf(x)             (x)
  #define MkBufferC_X2obj(x)             MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBufferS MkBufferCR;
  __parser__(ignore) typedef const struct MkBufferS MkBufferCNR;
  #define MkBufferC_T                    (&MK_RT_REF._MkBufferC_T)
  #define MkBufferC_TT                   (MkTYP(MkBufferC_T))
  #define MkBufferST                     MkBufferC_T
  #define MkBufferSTT                    (MkTYP(MkBufferST))
  #define MkBufferC_type                 MK_BUF
  #define MkBufferCT_X(instance)         ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBufferCTT_X(instance)        (MkOBJ_R(instance).type)
  #define MkBufferCT_TT(typ)             ( (struct MkSuperTypeS *) (typ) )
  #define MkBufferC_NS                   MK
  #define MkBufferCTT                    MkBufferCTT
  #define MkBufferCT                     ( (struct MkSuperTypeS *) MkBufferCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkBufferC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkBufCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkBufferC,mng);
  }
 
  __parser__(class=MkBufferC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkBufCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkBufferC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkBufferC_Check(mng)           MkBufCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkBufferC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_BUF MkBuf(MK_MNG mng) {
    return (MkBufCheck(mng) ? (MK_BUF)mng : NULL);
  }
 
  __parser__(class=MkBufferC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_BUFN MkBufN(MK_MNGN mng) {
    return (MkBufCheck(mng) ? (MK_BUFN)mng : NULL);
  }
 
  #define MkBufRaise(_buf) if (!_MkCheckX(MkBufferC,_buf)) { \
    MkErrorSetC_1E("'MkBufferC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkBUF_R(x)        (*(x)).super.buf
  #define   MkBUF(x)          (&MkBUF_R(x))
 
 
  __parser__pop__;
// MkBufferC_Class_Define_C_API
 
// END-MkBufferS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
// [MkBufferS_example]
 
// MkBufferC_C_API
 
// =========================================================================
// BEGIN-MkBufferS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkBufferC);
 
__parser__(class-overload=MkObjectHandleGet)
MK_ATTR_RT_INSTANCE
mk_inline MK_HDL MK_DECL MkBufferHandleGet_RT ( 
  MK_PARSER_RT
  MK_BUF const buf  __parser__(null-allowed)
) {
  return MkObjectHandleGet(buf?MkOBJ(buf):NULL);
}
 
__parser__(flags=new)
MK_ATTR_RT_STATIC
mk_inline MK_BUF MkBufferHandleResolve_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
) {
  return MkBuf(MkObjectHandleResolve(netHdl));
}
 
#define MkBufferHandleResolve_e(netHdl) ({ \
  MK_HDL tmpHdl=netHdl; \
  MK_BUF tmp; \
  if (tmpHdl==0) { \
    tmp=NULL; \
  } else { \
    tmp=MkBufferHandleResolve(tmpHdl); \
    if (tmp==NULL) { \
      MkErrorSetC_1_NULL("ERROR: 'MkBufferC' handle is 'NULL'"); \
      goto error; \
    }; \
  }; \
  tmp; \
})
 
__parser__pop__;
 
// Class export & import
 
  __parser__(flags=new,doc-group=_ignore_,doc-index=Class,doc-name=Misc,class=MkBufferC,null-return-allow)
  MK_ATTR_STATIC
  mk_inline MK_BUF MkBufferGetNull ( void ) {
    return (MK_BUF)MK_NULL;
  }
// MkBufferC - Misc - function
 
// MkBufferC_Class_C_API
 
// END-MkBufferS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// #######################################################################
// -----------------------------------------------------------------------
 
#define MkBuffer64S_ils_size (64) 
 
__parser__(ignore)
struct MkBuffer64S {
  // BEGIN-MkBuffer64S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
  } super;
 
  // END-MkBuffer64S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  MK_BINB ils_data[MkBuffer64S_ils_size];     
};
 
// BEGIN-MkBuffer64S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBuffer64C_SIGNATURE          (MkBufferC_SIGNATURE ^ (1u<<6))
  #define MkBuffer64C_MASK               (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBuffer64C_X2buf(x)           MkBUF(x)
  #define MkBuffer64C_X2obj(x)           MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBuffer64S MkBuffer64CR;
  __parser__(ignore) typedef const struct MkBuffer64S MkBuffer64CNR;
  #define MkBuffer64C_T                  (&MK_RT_REF._MkBuffer64C_T)
  #define MkBuffer64C_TT                 (MkTYP(MkBuffer64C_T))
  #define MkBuffer64ST                   MkBuffer64C_T
  #define MkBuffer64STT                  (MkTYP(MkBuffer64ST))
  #define MkBuffer64CT_X(instance)       ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBuffer64CTT_X(instance)      (MkOBJ_R(instance).type)
  #define MkBuffer64CT_TT(typ)           ( (struct MkSuperTypeS *) (typ) )
  #define MkBuffer64C_NS                 MK
  #define MkBuffer64CTT                  MkBuffer64CTT
  #define MkBuffer64CT                   ( (struct MkSuperTypeS *) MkBuffer64CTT )
 
 
  __parser__pop__;
// MkBuffer64C_Class_Define_C_API
 
// END-MkBuffer64S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkBuffer64C_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
#define MkBuffer256S_ils_size (256)
 
__parser__(ignore)
struct MkBuffer256S {
  // BEGIN-MkBuffer256S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
  } super;
 
  // END-MkBuffer256S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  MK_BINB ils_data[MkBuffer256S_ils_size];    
};
 
// BEGIN-MkBuffer256S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBuffer256C_SIGNATURE         (MkBufferC_SIGNATURE ^ (2u<<6))
  #define MkBuffer256C_MASK              (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBuffer256C_X2buf(x)          MkBUF(x)
  #define MkBuffer256C_X2obj(x)          MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBuffer256S MkBuffer256CR;
  __parser__(ignore) typedef const struct MkBuffer256S MkBuffer256CNR;
  #define MkBuffer256C_T                 (&MK_RT_REF._MkBuffer256C_T)
  #define MkBuffer256C_TT                (MkTYP(MkBuffer256C_T))
  #define MkBuffer256ST                  MkBuffer256C_T
  #define MkBuffer256STT                 (MkTYP(MkBuffer256ST))
  #define MkBuffer256CT_X(instance)      ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBuffer256CTT_X(instance)     (MkOBJ_R(instance).type)
  #define MkBuffer256CT_TT(typ)          ( (struct MkSuperTypeS *) (typ) )
  #define MkBuffer256C_NS                MK
  #define MkBuffer256CTT                 MkBuffer256CTT
  #define MkBuffer256CT                  ( (struct MkSuperTypeS *) MkBuffer256CTT )
 
 
  __parser__pop__;
// MkBuffer256C_Class_Define_C_API
 
// END-MkBuffer256S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkBuffer256C_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
#define MkBuffer1024S_ils_size (1024)
 
__parser__(ignore)
struct MkBuffer1024S {
  // BEGIN-MkBuffer1024S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
  } super;
 
  // END-MkBuffer1024S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  MK_BINB ils_data[MkBuffer1024S_ils_size];   
};
 
// BEGIN-MkBuffer1024S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBuffer1024C_SIGNATURE        (MkBufferC_SIGNATURE ^ (3u<<6))
  #define MkBuffer1024C_MASK             (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBuffer1024C_X2buf(x)         MkBUF(x)
  #define MkBuffer1024C_X2obj(x)         MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBuffer1024S MkBuffer1024CR;
  __parser__(ignore) typedef const struct MkBuffer1024S MkBuffer1024CNR;
  #define MkBuffer1024C_T                (&MK_RT_REF._MkBuffer1024C_T)
  #define MkBuffer1024C_TT               (MkTYP(MkBuffer1024C_T))
  #define MkBuffer1024ST                 MkBuffer1024C_T
  #define MkBuffer1024STT                (MkTYP(MkBuffer1024ST))
  #define MkBuffer1024CT_X(instance)     ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBuffer1024CTT_X(instance)    (MkOBJ_R(instance).type)
  #define MkBuffer1024CT_TT(typ)         ( (struct MkSuperTypeS *) (typ) )
  #define MkBuffer1024C_NS               MK
  #define MkBuffer1024CTT                MkBuffer1024CTT
  #define MkBuffer1024CT                 ( (struct MkSuperTypeS *) MkBuffer1024CTT )
 
 
  __parser__pop__;
// MkBuffer1024C_Class_Define_C_API
 
// END-MkBuffer1024S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkBuffer1024C_C_API
 
#ifndef __has_parser__
 
#define MkBuf2XXXfast(buf)          (*(buf)->storage.first.A)
 
#define MkBuf2BOLfast(buf)          MkBuf2XXXfast(buf).BOL
#define MkBuf2I8fast(buf)           MkBuf2XXXfast(buf).I8
#define MkBuf2I16fast(buf)          MkBuf2XXXfast(buf).I16
#define MkBuf2I32fast(buf)          MkBuf2XXXfast(buf).I32
#define MkBuf2I64fast(buf)          MkBuf2XXXfast(buf).I64
#define MkBuf2FLTfast(buf)          MkBuf2XXXfast(buf).FLT
#define MkBuf2DBLfast(buf)          MkBuf2XXXfast(buf).DBL
 
#define MkBuf2XXX(xxx,len,buf)  ({MK_##xxx __tmp; memcpy(&__tmp,buf->storage.first.B,len); __tmp;})
 
#define MkBuf2BOL(buf)          MkBuf2XXX(BOL,1,buf)
#define MkBuf2I8(buf)           MkBuf2XXX(I8,1,buf)
#define MkBuf2I16(buf)          MkBuf2XXX(I16,2,buf)
#define MkBuf2I32(buf)          MkBuf2XXX(I32,4,buf)
#define MkBuf2I64(buf)          MkBuf2XXX(I64,8,buf)
#define MkBuf2FLT(buf)          MkBuf2XXX(FLT,4,buf)
#define MkBuf2DBL(buf)          MkBuf2XXX(DBL,8,buf)
 
#define MkBuf2Ptr(len,ptr,buf)        memcpy((void*)ptr,buf->storage.first.B,len)
#define MkBuf2BOL_P(ptr,buf)          MkBuf2Ptr(1,ptr,buf)
#define MkBuf2I8_P(ptr,buf)           MkBuf2Ptr(1,ptr,buf)
#define MkBuf2I16_P(ptr,buf)          MkBuf2Ptr(2,ptr,buf)
#define MkBuf2I32_P(ptr,buf)          MkBuf2Ptr(4,ptr,buf)
#define MkBuf2I64_P(ptr,buf)          MkBuf2Ptr(8,ptr,buf)
#define MkBuf2FLT_P(ptr,buf)          MkBuf2Ptr(4,ptr,buf)
#define MkBuf2DBL_P(ptr,buf)          MkBuf2Ptr(8,ptr,buf)
 
#define MkBuf2Ptr_A(l,a,b)            memcpy(a.B##l,b->storage.first.B,l)
#define MkBuf2BOL_A(ato,buf)          MkBuf2Ptr_A(1,ato,buf)
#define MkBuf2I8_A(ato,buf)           MkBuf2Ptr_A(1,ato,buf)
#define MkBuf2I16_A(ato,buf)          MkBuf2Ptr_A(2,ato,buf)
#define MkBuf2I32_A(ato,buf)          MkBuf2Ptr_A(4,ato,buf)
#define MkBuf2I64_A(ato,buf)          MkBuf2Ptr_A(8,ato,buf)
#define MkBuf2FLT_A(ato,buf)          MkBuf2Ptr_A(4,ato,buf)
#define MkBuf2DBL_A(ato,buf)          MkBuf2Ptr_A(8,ato,buf)
 
// MkBuf2TT
 
#endif  // !__has_parser__
 
__parser__push__(hide,overload-c-no);
 
 
MK_EXTERN enum MkErrorE MK_DECL MkString2BOL_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_BOL          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2O(s,l,r)   MkString2BOL_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2I8_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_I8          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2Y(s,l,r)   MkString2I8_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2I16_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_I16          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2S(s,l,r)   MkString2I16_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2U16_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_U16          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2US(s,l,r)   MkString2U16_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2I32_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_I32          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2I(s,l,r)   MkString2I32_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2U32_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_U32          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2UI(s,l,r)  MkString2U32_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2I64_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_I64          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2W(s,l,r)   MkString2I64_RT(MK_RT_CALL s,l,r)
 
/*
MK_EXTERN enum MkErrorE MK_DECL MkString2LLG_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_LLG          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2X(s,l,r)   MkString2LLG_RT(MK_RT_CALL s,l,r)
*/
 
MK_EXTERN enum MkErrorE MK_DECL MkString2FLT_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_FLT          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2F(s,l,r)   MkString2FLT_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2DBL_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_DBL          *val_out
) MK_ATTR_RT_STATIC;
 
#define MkString2D(s,l,r)   MkString2DBL_RT(MK_RT_CALL s,l,r)
 
MK_EXTERN enum MkErrorE MK_DECL MkString2LONG_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_LONG         *val_out
) MK_ATTR_RT_STATIC;
 
MK_EXTERN enum MkErrorE MK_DECL MkString2BOOL_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_BOOL         *val_out
) MK_ATTR_RT_STATIC;
 
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkString2ATO_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  enum MkTypeE    type,
  MK_ATO          *val_out
) MK_ATTR_RT_STATIC;
 
MK_EXTERN enum MkErrorE MK_DECL MkString2HDL_RT (
  MK_PARSER_RT
  MK_STRN const   str,
  MK_NUM  const   length,
  MK_HDL          *val_out
) MK_ATTR_RT_STATIC;
 
__parser__pop__;
 
// MkString2TT
// MkBufferC_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=TOR);
 
// [MkBufferCreate]
__parser__(constructor,lng-constr)
MK_EXTERN MK_BUF MK_DECL MkBufferCreate_RT (
  MK_PARSER_RT
  MK_TYP        type    __parser__(internal,default=NULL),
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
// [MkBufferCreate]
 
__parser__(constructor,doc-sort=ils0)
MK_EXTERN MK_BUF MK_DECL MkBufferCreate64_RT (
  MK_PARSER_RT
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor,doc-sort=ils1)
MK_EXTERN MK_BUF MK_DECL MkBufferCreate256_RT (
  MK_PARSER_RT
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor,doc-sort=ils2)
MK_EXTERN MK_BUF MK_DECL MkBufferCreate1024_RT (
  MK_PARSER_RT
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor,macro,doc-sort=tmpl0)
void MkBufferCreateTLS_T(MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size) MK_ATTR_STATIC ;
// [MkBufferCreateTLS_T]
#define MkBufferCreateTLS_T(cls,name,size)          \
  static MkThreadLocal cls##R name##R = {0};        \
  MK_BUF name = MkBUF(&name##R);                    \
  if (unlikely(!__MkCheckX(cls,&name##R))) {        \
    MkBufferInit(name,cls##_TT,size);               \
    MkRefIncr_1X(name);                             \
  } else if (MkBUF_R(&name##R).var.cursize) {       \
    MkBufferReset(name);                            \
  }
// [MkBufferCreateTLS_T]
 
__parser__(constructor,macro,doc-sort=tmpl1)
void MkBufferCreateTLS_inout_T(MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_BUF * inout) MK_ATTR_STATIC ;
// [MkBufferCreateTLS_inout_T]
#define MkBufferCreateTLS_inout_T(cls,name,inout)                    \
  static MkThreadLocal struct MkBufferS __hidden_##name##R = {0};    \
  MK_BUF name = *inout != NULL ? *inout : &__hidden_##name##R;       \
  if (likely(!__MkCheckX(MkBufferC,name))) {                         \
    MkBufferInit(name,cls##_TT,0);                                   \
    MkRefIncr_1X(name);                                              \
  } else if (name->var.cursize) {                                    \
    MkBufferReset(name);                                             \
  }                                                                  \
// [MkBufferCreateTLS_inout_T]
 
__parser__(constructor,macro,doc-sort=tmpl2)
void MkBufferCreateLOCAL_T(MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size) MK_ATTR_STATIC ;
// [MkBufferCreateLOCAL_T]
#define MkBufferCreateLOCAL_T(cls,name,size)        \
  cls##R name##R = {0};                             \
  struct MkBufferS * const name = MkBUF(&name##R);  \
  MkBufferInit(name,cls##_TT,size)
// [MkBufferCreateLOCAL_T]
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateI8_RT (
  MK_PARSER_RT
  MK_I8 const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateBOL_RT (
  MK_PARSER_RT
  MK_BOL const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateI16_RT (
  MK_PARSER_RT
  MK_I16 const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateI32_RT (
  MK_PARSER_RT
  MK_I32 const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateFLT_RT (
  MK_PARSER_RT
  MK_FLT const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateI64_RT (
  MK_PARSER_RT
  MK_I64 const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateDBL_RT (
  MK_PARSER_RT
  MK_DBL const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateSTR_RT (
  MK_PARSER_RT
  MK_STRN const val
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateBIN_RT (
  MK_PARSER_RT
  MkBinaryR const val
) MK_ATTR_RT_STATIC;
 
__parser__(doc-sort=b0)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateTLS_RT (
  MK_PARSER_RT
  MK_STRN const tlsName ,
  bool    const resetB    __parser__(default=true)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor,static,doc-sort=b1)
MK_EXTERN MK_BUF MK_DECL MkBufferCreateBUF_RT (
  MK_PARSER_RT
  MK_BUFN const val
) MK_ATTR_RT_STATIC;
 
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferFree_RT (
  MK_PARSER_RT
  MK_BUF  const buf
) MK_ATTR_RT_INSTANCE;
 
// [MkBufferInit]
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferInit_RT (
  MK_PARSER_RT
  MK_BUF  const buf,
  MK_TYP        type    __parser__(internal,default=NULL),
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
// [MkBufferInit]
 
__parser__(destructor)
MK_EXTERN void MK_DECL MkBufferDelete_RT (
  MK_PARSER_RT
  MK_BUF const buf
) MK_ATTR_RT_INSTANCE;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferDup_RT (
  MK_PARSER_RT
  MK_BUFN const buf
) MK_ATTR_RT_INSTANCE;
 
__parser__(constructor)
MK_EXTERN MK_BUF MK_DECL MkBufferMerge_RT (
  MK_PARSER_RT
  MK_BUF const buf
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // TOR
 
// MkBufferC_TOR_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__global__(prefix2doc:MkBufferGet=Get);
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetI8_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_I8 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetBOL_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_BOL * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetI16_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_I16 * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetU16_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_U16 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetI32_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_I32 * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetU32_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_U32 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetFLT_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_FLT * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetI64_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_I64 * const val_out
) MK_ATTR_RT_INSTANCE;
 
/*
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetLL_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_LLG * const val_out
) MK_ATTR_RT_INSTANCE;
 
#define MkBufferGetLLG(b,o)  MkBufferGetLL(b,o)
*/
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetDBL_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_DBL * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetBIN_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MkBinaryR * const val_out
) MK_ATTR_RT_INSTANCE;
 
// [__parser__out__]
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetSTR_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_STRN * const val_out
) MK_ATTR_RT_INSTANCE;
// [__parser__out__]
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetStringR_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MkStringR * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetBUF_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_BUF * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-static)
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetBFL_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_BFL * const val_inout
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetLONG_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_LONG * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkBufferGetBOOL_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_BOOL * const val_out
) MK_ATTR_RT_INSTANCE;
 
// MkBufferC_Get_C_API
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__global__(prefix2doc:MkBufferSet=Set);
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetI8_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_I8 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetBOL_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_BOL const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetI16_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_I16 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetI32_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_I32 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetFLT_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_FLT const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetI64_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_I64 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetDBL_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_DBL const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetSTR_RT (
  MK_PARSER_RT
  MK_BUF  const buf,
  MK_STRN const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetBIN_RT (
  MK_PARSER_RT
  MK_BUF    const buf,
  MkBinaryR const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetBUF_RT (
  MK_PARSER_RT
  MK_BUF  const buf,
  MK_BUFN const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetVL_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_FST const val,
  va_list var_list
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetV_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_FST const val,
  ...
) MK_ATTR_RT_INSTANCE MK_RT_ATTR_FORMAT_2;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetBinaryR_RT (
  MK_PARSER_RT
  MK_BUF    const buf,
  MkBinaryR const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferSetStringR_RT (
  MK_PARSER_RT
  MK_BUF    const buf,
  MkStringR const val
) MK_ATTR_RT_INSTANCE;
 
// MkBufferC_Set_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Info);
 
__parser__(no-rpc)
MK_EXTERN MK_STRB MK_DECL MkBufferGetType1_RT (
  MK_PARSER_RT
  MK_BUFN const buf
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkTypeE MK_DECL MkBufferGetType2_RT (
  MK_PARSER_RT
  MK_BUFN const buf
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_STRN MK_DECL MkBufferGetType3_RT (
  MK_PARSER_RT
  MK_BUFN const buf
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN bool MK_DECL MkBufferIsLocal_RT (
  MK_PARSER_RT
  MK_BUFN const buf
) MK_ATTR_RT_INSTANCE;
 
__parser__(const,class-overload=MkObjectLog)
MK_EXTERN void MK_DECL MkBufferLog_RT (
  MK_PARSER_RT
  MK_BUFN const buf,
  MK_PARSER_fmtobj        ,
  MK_DBG  const debug     __parser__(default=0),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferLogSS_RT (
  MK_PARSER_RT
  MK_BUFN const  buf,
  MK_STRN const  varname     __parser__(default=S#"buf"),
  MK_PARSER_fmtobj           ,
  MK_STRN const  callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferLogS_RT (
  MK_PARSER_RT
  MK_BUFN const  buf,
  MK_STRN const  varname     __parser__(default=S#"buf"),
  MK_PARSER_fmtobj           ,
  MK_STRN const  callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
#define MkBufferLogS_2V(buf,fmt)  MkBufferLogS_3(buf,#fmt,MkOBJ(fmt))
 
__parser__pop__;
 
// MkBufferC_Info_C_API
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
MK_EXTERN MK_I32 MK_DECL MkBufferCmp_RT (
  MK_PARSER_RT
  MK_BUFN const buf1,
  MK_BUFN const buf2
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE
MK_DECL MkBufferCastTo_RT (
  MK_PARSER_RT
  MK_BUF const buf,         // TODO: special case update buffer should  be default return
  enum MkTypeE const typ
) MK_ATTR_RT_INSTANCE;
 
__parser__(class-overload=MkObjectToString)
MK_EXTERN MK_STRN
MK_DECL MkBufferToString_RT (
  MK_PARSER_RT
  MK_BUFN const inst
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF
MK_DECL MkBufferSizeNew_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_NUM const size
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF
MK_DECL MkBufferSizeAdd_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_NUM const size
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUF MK_DECL MkBufferReset_RT (
  MK_PARSER_RT
  MK_BUF const buf
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferResetFull_RT (
  MK_PARSER_RT
  MK_BUF const buf
) MK_ATTR_RT_INSTANCE;
 
__parser__(const)
MK_EXTERN MK_BUF MK_DECL MkBufferCopy_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_BUFN const srce
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-static)
MK_EXTERN MK_BUF MK_DECL MkBufferTemp_RT (
  MK_PARSER_RT
  MK_BUFN const buf
) MK_ATTR_RT_INSTANCE;
 
// MkBufferC_Misc_C_API
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Access);
 
__parser__(no-type-extension)
MK_EXTERN MK_BUF MK_DECL MkBufferAppendSTR_RT (
  MK_PARSER_RT
  MK_BUF  const buf,
  MK_STRN const val
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension)
MK_EXTERN MK_BUF MK_DECL MkBufferAppendStringR_RT (
  MK_PARSER_RT
  MK_BUF    const buf,
  MkStringR const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_I32 MK_DECL MkBufferAppendVL_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_FST const printfmt,
  va_list var_list
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_I32 MK_DECL MkBufferAppendV_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_FST const printfmt,
  ...
) MK_ATTR_RT_INSTANCE MK_RT_ATTR_FORMAT_2;
 
MK_EXTERN MK_NUM MK_DECL MkBufferPush_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_STRN const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_NUM MK_DECL MkBufferPop_RT (
  MK_PARSER_RT
  MK_BUF const buf,
  MK_STRN const val
) MK_ATTR_RT_INSTANCE;
 
__parser__(template-required,no-rpc,keep,no-static)
MK_EXTERN enum MkErrorE MK_DECL MkBufferToObject_RT (
  MK_PARSER_RT
  MK_BUF        const buf,
  MK_NAT_OBJECT *     obj_out
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__;
 
// MkBufferC_Access_C_API
 
/* MARK_S ################################################################ */
/* ###                                                                 ### */
/* ###              B U F F E R - S T R E A M - A P I                  ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
 
struct MkBufferStreamSaveS;
 
#define MkBufferStreamS_ils_size (0)
 
// [MkBufferStreamS_example]
struct MkBufferStreamS {
  // BEGIN-MkBufferStreamS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
  } super;
 
  // END-MkBufferStreamS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  struct {
    MK_NUM numItems;                            // the number of items in the package
    MK_I32 undo;                                // \e undo last operation: read=+1 < no=0 < write=-1)
    // \note The \e endian_is_wrong attribute is required if a \RMkBufferStreamC is send to
    // an other host. The \e sender-endian is part of the \e package-header and the \e reader is using
    // the information from the \e package-header to setup the \e endian_is_wrong attribute.
    // \li \b false (0) if the endian is the \b same as the local endian.
    // \li \b true  (1) if the endian is \b not the same as the local endian.
    // If \e endian_is_wrong is \b true the package header transform the native-binary-package-data
    // to the local endian as part of the \RDocMqA{ReadTT} and \RDocNsA{BufferStreamReadTT} methods.
    // The transformation of native data is \b only done if required, just \e routing of a package
    // does \b not require a transformation.
    bool endian_is_wrong;                       // the value: \e TRUE if endian of storage != \c MK_ENDIAN_MY
  } var;                                        // variable part of the \e instance-data
  struct {
    union MkBufferU cur;
  } storage;                                    // storage part of the \e instance-data
 
  // BUG FIX don't put busRef into "var" -> the pMkBusReadL_END will "overwrite" the data including the
  // "self" pointer
  struct MkBuffer64S              busRef;           // pBusReadNextWord will fill this
 
  struct MkCacheS                   saveCache;      // cache to support recursion in LST sub-package
  struct MkBufferStreamSaveS      * busWriteSave;   // if \b not NULL than an active LST-WRITE is ongoing
  struct MkBufferStreamSaveS      * busReadSave;    // if \b not NULL than an active LST-READ is ongoing
 
  MK_BINB ils_data[MkBufferStreamS_ils_size];   // \e ILS storage
};
// [MkBufferStreamS_example]
 
// BEGIN-MkBufferStreamS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBufferStreamC_SIGNATURE      (MkBufferC_SIGNATURE ^ (4u<<6))
  #define MkBufferStreamC_MASK           (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBufferStreamC_X2bus(x)       (x)
  #define MkBufferStreamC_X2buf(x)       MkBUF(x)
  #define MkBufferStreamC_X2obj(x)       MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBufferStreamS MkBufferStreamCR;
  __parser__(ignore) typedef const struct MkBufferStreamS MkBufferStreamCNR;
  #define MkBufferStreamC_T              (&MK_RT_REF._MkBufferStreamC_T)
  #define MkBufferStreamC_TT             (MkTYP(MkBufferStreamC_T))
  #define MkBufferStreamST               MkBufferStreamC_T
  #define MkBufferStreamSTT              (MkTYP(MkBufferStreamST))
  #define MkBufferStreamC_type           MK_BUS
  #define MkBufferStreamCT_X(instance)   ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBufferStreamCTT_X(instance)  (MkOBJ_R(instance).type)
  #define MkBufferStreamCT_TT(typ)       ( (struct MkSuperTypeS *) (typ) )
  #define MkBufferStreamC_NS             MK
  #define MkBufferStreamCTT              MkBufferStreamCTT
  #define MkBufferStreamCT               ( (struct MkSuperTypeS *) MkBufferStreamCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkBufferStreamC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkBusCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkBufferStreamC,mng);
  }
 
  __parser__(class=MkBufferStreamC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkBusCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkBufferStreamC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkBufferStreamC_Check(mng)     MkBusCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkBufferStreamC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_BUS MkBus(MK_MNG mng) {
    return (MkBusCheck(mng) ? (MK_BUS)mng : NULL);
  }
 
  __parser__(class=MkBufferStreamC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_BUSN MkBusN(MK_MNGN mng) {
    return (MkBusCheck(mng) ? (MK_BUSN)mng : NULL);
  }
 
  #define MkBusRaise(_bus) if (!_MkCheckX(MkBufferStreamC,_bus)) { \
    MkErrorSetC_1E("'MkBufferStreamC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkBUS_R(x)        (*(x)).super.bus
  #define   MkBUS(x)          (&MkBUS_R(x))
 
 
  __parser__pop__;
// MkBufferStreamC_Class_Define_C_API
 
// END-MkBufferStreamS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// =========================================================================
// BEGIN-MkBufferStreamS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkBufferStreamC);
 
__parser__(class-overload=MkObjectHandleGet)
MK_ATTR_RT_INSTANCE
mk_inline MK_HDL MK_DECL MkBufferStreamHandleGet_RT ( 
  MK_PARSER_RT
  MK_BUS const bus  __parser__(null-allowed)
) {
  return MkObjectHandleGet(bus?MkOBJ(bus):NULL);
}
 
__parser__(flags=new)
MK_ATTR_RT_STATIC
mk_inline MK_BUS MkBufferStreamHandleResolve_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
) {
  return MkBus(MkObjectHandleResolve(netHdl));
}
 
#define MkBufferStreamHandleResolve_e(netHdl) ({ \
  MK_HDL tmpHdl=netHdl; \
  MK_BUS tmp; \
  if (tmpHdl==0) { \
    tmp=NULL; \
  } else { \
    tmp=MkBufferStreamHandleResolve(tmpHdl); \
    if (tmp==NULL) { \
      MkErrorSetC_1_NULL("ERROR: 'MkBufferStreamC' handle is 'NULL'"); \
      goto error; \
    }; \
  }; \
  tmp; \
})
 
__parser__pop__;
 
// Class export & import
 
  __parser__(flags=new,doc-group=_ignore_,doc-index=Class,doc-name=Misc,class=MkBufferStreamC,null-return-allow)
  MK_ATTR_STATIC
  mk_inline MK_BUS MkBufferStreamGetNull ( void ) {
    return (MK_BUS)MK_NULL;
  }
// MkBufferStreamC - Misc - function
 
// MkBufferStreamC_Class_C_API
 
// END-MkBufferStreamS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// #######################################################################
// -----------------------------------------------------------------------
 
#define MkBufferStream64_ils_size (64)
 
__parser__(ignore)
struct MkBufferStream64S {
  // BEGIN-MkBufferStream64S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
    struct MkBufferStreamS      bus;          // instance-base MkBufferStreamS
  } super;
 
  // END-MkBufferStream64S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  MK_BINB ils_data[MkBufferStream64_ils_size];      
};
 
// BEGIN-MkBufferStream64S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBufferStream64C_SIGNATURE    (MkBufferStreamC_SIGNATURE ^ (3u<<3))
  #define MkBufferStream64C_MASK         (((1u<<29)-1)<<3)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBufferStream64C_X2bus(x)     MkBUS(x)
  #define MkBufferStream64C_X2buf(x)     MkBUF(x)
  #define MkBufferStream64C_X2obj(x)     MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBufferStream64S MkBufferStream64CR;
  __parser__(ignore) typedef const struct MkBufferStream64S MkBufferStream64CNR;
  #define MkBufferStream64C_T            (&MK_RT_REF._MkBufferStream64C_T)
  #define MkBufferStream64C_TT           (MkTYP(MkBufferStream64C_T))
  #define MkBufferStream64ST             MkBufferStream64C_T
  #define MkBufferStream64STT            (MkTYP(MkBufferStream64ST))
  #define MkBufferStream64CT_X(instance) ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBufferStream64CTT_X(instance) (MkOBJ_R(instance).type)
  #define MkBufferStream64CT_TT(typ)     ( (struct MkSuperTypeS *) (typ) )
  #define MkBufferStream64C_NS           MK
  #define MkBufferStream64CTT            MkBufferStream64CTT
  #define MkBufferStream64CT             ( (struct MkSuperTypeS *) MkBufferStream64CTT )
 
 
  __parser__pop__;
// MkBufferStream64C_Class_Define_C_API
 
// END-MkBufferStream64S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
#define MkBufferStream256S_ils_size (256)
 
__parser__(ignore)
struct MkBufferStream256S {
  // BEGIN-MkBufferStream256S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
    struct MkBufferStreamS      bus;          // instance-base MkBufferStreamS
  } super;
 
  // END-MkBufferStream256S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  MK_BINB ils_data[MkBufferStream256S_ils_size];    
};
 
// BEGIN-MkBufferStream256S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBufferStream256C_SIGNATURE   (MkBufferStreamC_SIGNATURE ^ (2u<<3))
  #define MkBufferStream256C_MASK        (((1u<<29)-1)<<3)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBufferStream256C_X2bus(x)    MkBUS(x)
  #define MkBufferStream256C_X2buf(x)    MkBUF(x)
  #define MkBufferStream256C_X2obj(x)    MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBufferStream256S MkBufferStream256CR;
  __parser__(ignore) typedef const struct MkBufferStream256S MkBufferStream256CNR;
  #define MkBufferStream256C_T           (&MK_RT_REF._MkBufferStream256C_T)
  #define MkBufferStream256C_TT          (MkTYP(MkBufferStream256C_T))
  #define MkBufferStream256ST            MkBufferStream256C_T
  #define MkBufferStream256STT           (MkTYP(MkBufferStream256ST))
  #define MkBufferStream256CT_X(instance) ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBufferStream256CTT_X(instance) (MkOBJ_R(instance).type)
  #define MkBufferStream256CT_TT(typ)    ( (struct MkSuperTypeS *) (typ) )
  #define MkBufferStream256C_NS          MK
  #define MkBufferStream256CTT           MkBufferStream256CTT
  #define MkBufferStream256CT            ( (struct MkSuperTypeS *) MkBufferStream256CTT )
 
 
  __parser__pop__;
// MkBufferStream256C_Class_Define_C_API
 
// END-MkBufferStream256S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
#define MkBufferStream1024_ils_size (1024)
 
__parser__(ignore)
struct MkBufferStream1024S {
  // BEGIN-MkBufferStream1024S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
    struct MkBufferStreamS      bus;          // instance-base MkBufferStreamS
  } super;
 
  // END-MkBufferStream1024S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  MK_BINB ils_data[MkBufferStream1024_ils_size];    
};
 
// BEGIN-MkBufferStream1024S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBufferStream1024C_SIGNATURE  (MkBufferStreamC_SIGNATURE ^ (4u<<3))
  #define MkBufferStream1024C_MASK       (((1u<<29)-1)<<3)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBufferStream1024C_X2bus(x)   MkBUS(x)
  #define MkBufferStream1024C_X2buf(x)   MkBUF(x)
  #define MkBufferStream1024C_X2obj(x)   MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBufferStream1024S MkBufferStream1024CR;
  __parser__(ignore) typedef const struct MkBufferStream1024S MkBufferStream1024CNR;
  #define MkBufferStream1024C_T          (&MK_RT_REF._MkBufferStream1024C_T)
  #define MkBufferStream1024C_TT         (MkTYP(MkBufferStream1024C_T))
  #define MkBufferStream1024ST           MkBufferStream1024C_T
  #define MkBufferStream1024STT          (MkTYP(MkBufferStream1024ST))
  #define MkBufferStream1024CT_X(instance) ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBufferStream1024CTT_X(instance) (MkOBJ_R(instance).type)
  #define MkBufferStream1024CT_TT(typ)   ( (struct MkSuperTypeS *) (typ) )
  #define MkBufferStream1024C_NS         MK
  #define MkBufferStream1024CTT          MkBufferStream1024CTT
  #define MkBufferStream1024CT           ( (struct MkSuperTypeS *) MkBufferStream1024CTT )
 
 
  __parser__pop__;
// MkBufferStream1024C_Class_Define_C_API
 
// END-MkBufferStream1024S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// #######################################################################
// -----------------------------------------------------------------------
 
#define MkBufferStream16384S_ils_size (16384)
 
__parser__(ignore)
struct MkBufferStream16384S {
  // BEGIN-MkBufferStream16384S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkBufferS            buf;          // instance-base MkBufferS
    struct MkBufferStreamS      bus;          // instance-base MkBufferStreamS
  } super;
 
  // END-MkBufferStream16384S-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  MK_BINB ils_data[MkBufferStream16384S_ils_size];         
};
 
// BEGIN-MkBufferStream16384S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkBufferStream16384C_SIGNATURE (MkBufferStreamC_SIGNATURE ^ (1u<<3))
  #define MkBufferStream16384C_MASK      (((1u<<29)-1)<<3)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkBufferStream16384C_X2bus(x)  MkBUS(x)
  #define MkBufferStream16384C_X2buf(x)  MkBUF(x)
  #define MkBufferStream16384C_X2obj(x)  MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkBufferStream16384S MkBufferStream16384CR;
  __parser__(ignore) typedef const struct MkBufferStream16384S MkBufferStream16384CNR;
  #define MkBufferStream16384C_T         (&MK_RT_REF._MkBufferStream16384C_T)
  #define MkBufferStream16384C_TT        (MkTYP(MkBufferStream16384C_T))
  #define MkBufferStream16384ST          MkBufferStream16384C_T
  #define MkBufferStream16384STT         (MkTYP(MkBufferStream16384ST))
  #define MkBufferStream16384CT_X(instance) ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkBufferStream16384CTT_X(instance) (MkOBJ_R(instance).type)
  #define MkBufferStream16384CT_TT(typ)  ( (struct MkSuperTypeS *) (typ) )
  #define MkBufferStream16384C_NS        MK
  #define MkBufferStream16384CTT         MkBufferStream16384CTT
  #define MkBufferStream16384CT          ( (struct MkSuperTypeS *) MkBufferStream16384CTT )
 
 
  __parser__pop__;
// MkBufferStream16384C_Class_Define_C_API
 
// END-MkBufferStream16384S-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__(ignore)
typedef struct MkBufferStream16384S  MkBufferStream16384R;
 
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                  BufferStream - T O R - Api                     ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
__parser__push__(doc-group=TOR);
 
__parser__(constructor,lng-constr)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamCreate_RT (
  MK_PARSER_RT
  MK_TYP        type    __parser__(internal,default=NULL),
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
#define MkBufferStreamCreate_1(size)    MkBufferStreamCreate(NULL,size)
 
__parser__(constructor)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamCreate64_RT (
  MK_PARSER_RT
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamCreate256_RT (
  MK_PARSER_RT
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamCreate1024_RT (
  MK_PARSER_RT
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamCreate16384_RT (
  MK_PARSER_RT
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_STATIC;
 
MK_EXTERN MK_BUS MK_DECL MkBufferStreamCreateTLS_RT (
  MK_PARSER_RT
  MK_STRN const tlsName ,
  bool    const resetB    __parser__(default=true)
) MK_ATTR_RT_STATIC;
 
__parser__(constructor,macro)
void MkBufferStreamCreateLOCAL_T (MK_MACRO_TYP cls, MK_MACRO_TYP name, MK_NUM const size) MK_ATTR_STATIC ;
// [MkBufferStreamCreateLOCAL_T]
#define MkBufferStreamCreateLOCAL_T(cls,name,size)                \
  cls##R name##R = {0};                                           \
  struct MkBufferStreamS * const name = cls##_X2bus(&name##R);    \
  MkBufferStreamInit(name,cls##_TT,size)
// [MkBufferStreamCreateLOCAL_T]
 
__parser__(constructor,macro)
void MkBufferStreamCreateSTATIC_T(MK_MACRO_TYP cls, MK_MACRO_TYP name) MK_ATTR_STATIC ;
// [MkBufferStreamCreateSTATIC_T]
#define MkBufferStreamCreateSTATIC_T(cls,name)                    \
  static cls##R name##R = {0};                                    \
  struct MkBufferStreamS * const name = cls##_X2bus(&name##R);    \
  if (__MkCheckX(cls,&name##R)) {                                 \
    MkBufferStreamReset(name);                                    \
  } else {                                                        \
    MkBufferStreamInit(name,cls##TT,0);                           \
  }                                                               \
// [MkBufferStreamCreateSTATIC_T]
 
__parser__(constructor,macro)
void MkBufferStreamCreateTLS_T(MK_MACRO_TYP cls, MK_MACRO_TYP name) MK_ATTR_STATIC ;
// [MkBufferStreamCreateTLS_T]
#define MkBufferStreamCreateTLS_T(cls,name)                       \
  static MkThreadLocal cls##R name##R = {0};                      \
  struct MkBufferStreamS * const name = cls##_X2bus(&name##R);    \
  if (__MkCheckX(cls,&name##R)) {                                 \
    MkBufferStreamReset(name);                                    \
  } else {                                                        \
    MkBufferStreamInit(name,cls##_TT,0);                          \
  }                                                               \
// [MkBufferStreamCreateTLS_T]
 
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferStreamFree_RT (
  MK_PARSER_RT
  MK_BUS  const bus
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferStreamInit_RT (
  MK_PARSER_RT
  MK_BUS  const bus,
  MK_TYP        type    __parser__(internal,default=NULL),
  MK_NUM  const size    __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
__parser__(destructor)
MK_EXTERN void MK_DECL MkBufferStreamDelete_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
__parser__(constructor)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamMerge_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
__parser__(constructor)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamDup_RT (
  MK_PARSER_RT
  MK_BUSN const src
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__;
 
// MkBufferStreamC_TOR_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                 BufferStream - M I S C - Api                    ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
__parser__push__(doc-group=Misc);
 
__parser__(const)
MK_EXTERN MK_BUS MK_DECL MkBufferStreamCopy_RT (
  MK_PARSER_RT
  MK_BUS  const bus,
  MK_BUSN const src
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BUS MK_DECL MkBufferStreamReset_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkBufferStreamResetFull_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN void MK_DECL MkBufferStreamLogS_RT (
  MK_PARSER_RT
  MK_BUS  const bus         ,
  MK_OBJ        fmtobj      __parser__(default=NULL),
  MK_STRN const callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
// [MkBufferStreamLog_RT]
__parser__(const,class-overload=MkObjectLog)
MK_EXTERN void MK_DECL MkBufferStreamLog_RT (
  MK_PARSER_RT
  MK_BUS  const bus       ,
  MK_PARSER_fmtobj        ,
  MK_DBG  const debug     __parser__(default=0),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
#define MkBufferStreamLog_5F(bus,fmt,...)   MkBufferStreamLog(bus,MkObj(fmt),__VA_ARGS__)
#define MkBufferStreamLog_2F(bus,fmt)       MkBufferStreamLog_5F(bus,fmt,0,__func__,0)
#define MkBufferStreamLog_3F(bus,fmt,pfx)   MkBufferStreamLog_5F(bus,fmt,0,pfx,0)
// [MkBufferStreamLog_RT]
 
MK_EXTERN void MK_DECL MkBufferStreamPosToStart_RT  (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
__parser__(class-overload=MkObjectToString)
MK_EXTERN MK_STRN MK_DECL MkBufferStreamToString_RT  (
  MK_PARSER_RT
  MK_BUSN const inst
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_BFL MK_DECL MkBufferStreamToBFL_RT  (
  MK_PARSER_RT
  MK_BUSN const bus
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__;  // Misc
 
// MkBufferStreamC_Misc_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                BufferStream - W R I T E - Api                   ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
__parser__push__(doc-group=Write);
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteI8_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_I8 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteBOL_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BOL const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteI32_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_I32 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteFLT_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_FLT const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteI64_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_I64 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteDBL_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_DBL const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteSTR_RT (
  MK_PARSER_RT
  MK_BUS  const bus,
  MK_STRN const val,
  MK_NUM  const len   __parser__(default=-1)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteBIN_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MkBinaryR const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteBUF_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BUFN const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteHDL_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_I32 const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteLONG_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_LONG const val
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteVL_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_STRN const fmt,
  va_list ap
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteV_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_STRN const fmt,
  ...
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteBFL_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BFLN const bfl
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteL_FLAT_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BFL const bfl
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteL_START_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteL_END_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamWriteBUS_FLAT_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BUSN const add
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // Write
 
// MkBufferStreamC_Write_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                 BufferStream - R E A D - Api                    ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
__parser__push__(doc-group=Read);
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadL_START_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BUF       buf        __parser__(default=NULL)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadL_END_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadALL_RT (
  MK_PARSER_RT
  MK_BUS   const bus,
  MK_BFL * const val_inout
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadBFL_RT (
  MK_PARSER_RT
  MK_BUS   const bus,
  MK_BFL * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(ignore)
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadLIST_RT (
  MK_PARSER_RT
  MK_BUS   const bus,
  MK_NAT_LIST * const val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(ignore)
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadNEXT_RT (
  MK_PARSER_RT
  MK_BUS   const bus,
  MK_NAT_OBJECT * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadLONG_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_LONG * const val_out
) MK_ATTR_RT_INSTANCE;
 
// *******
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadI8_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_I8 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadBOL_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BOL * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadI32_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_I32 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadFLT_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_FLT * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadI64_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_I64 * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadDBL_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_DBL * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadSTR_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_STRN * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadBIN_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MkBinaryR * const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadBUF_RT (
  MK_PARSER_RT
  MK_BUS const bus,
  MK_BUF*const val_out
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN bool MK_DECL MkBufferStreamReadItemExists_RT (
  MK_PARSER_RT
  MK_BUSN const bus
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkTypeE MK_DECL MkBufferStreamReadGetNextType_RT (
  MK_PARSER_RT
  MK_BUSN const bus
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN MK_NUM MK_DECL MkBufferStreamReadGetNumItems_RT (
  MK_PARSER_RT
  MK_BUSN const bus
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkBufferStreamReadUndo_RT (
  MK_PARSER_RT
  MK_BUS const bus
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // Read
 
// MkBufferStreamC_Read_C_API
 
// MkBufferStreamC_C_API
 
/* MARK_L ################################################################ */
/* ###                                                                 ### */
/* ###                 B U F F E R - L I S T - A P I                   ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
END_MK_C_DECLS
#include "MkBufferListC_def_mk.h"
BEGIN_MK_C_DECLS
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                 L O G - F I L E - A P I                         ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
struct MkLogFileS {
  // BEGIN-MkLogFileS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkLogFileS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // object body
  MK_STRN  filename;
  FILE *  FH;
};
 
// BEGIN-MkLogFileS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkLogFileC_SIGNATURE           (MkObjectC_SIGNATURE ^ (3u<<10))
  #define MkLogFileC_MASK                (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkLogFileC_X2lfl(x)            (x)
  #define MkLogFileC_X2obj(x)            MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkLogFileS MkLogFileCR;
  __parser__(ignore) typedef const struct MkLogFileS MkLogFileCNR;
  #define MkLogFileC_T                   (&MK_RT_REF._MkLogFileC_T)
  #define MkLogFileC_TT                  (MkTYP(MkLogFileC_T))
  #define MkLogFileST                    MkLogFileC_T
  #define MkLogFileSTT                   (MkTYP(MkLogFileST))
  #define MkLogFileC_type                MK_LFL
  #define MkLogFileCT_X(instance)        ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkLogFileCTT_X(instance)       (MkOBJ_R(instance).type)
  #define MkLogFileCT_TT(typ)            ( (struct MkSuperTypeS *) (typ) )
  #define MkLogFileC_NS                  MK
  #define MkLogFileCTT                   MkLogFileCTT
  #define MkLogFileCT                    ( (struct MkSuperTypeS *) MkLogFileCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkLogFileC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkLflCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkLogFileC,mng);
  }
 
  __parser__(class=MkLogFileC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkLflCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkLogFileC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkLogFileC_Check(mng)          MkLflCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkLogFileC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_LFL MkLfl(MK_MNG mng) {
    return (MkLflCheck(mng) ? (MK_LFL)mng : NULL);
  }
 
  __parser__(class=MkLogFileC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_LFLN MkLflN(MK_MNGN mng) {
    return (MkLflCheck(mng) ? (MK_LFLN)mng : NULL);
  }
 
  #define MkLflRaise(_lfl) if (!_MkCheckX(MkLogFileC,_lfl)) { \
    MkErrorSetC_1E("'MkLogFileC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkLFL_R(x)        (*(x)).super.lfl
  #define   MkLFL(x)          (&MkLFL_R(x))
 
 
  __parser__pop__;
// MkLogFileC_Class_Define_C_API
 
// END-MkLogFileS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// =========================================================================
// BEGIN-MkLogFileS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkLogFileC);
 
__parser__(class-overload=MkObjectHandleGet)
MK_ATTR_RT_INSTANCE
mk_inline MK_HDL MK_DECL MkLogFileHandleGet_RT ( 
  MK_PARSER_RT
  MK_LFL const lfl  __parser__(null-allowed)
) {
  return MkObjectHandleGet(lfl?MkOBJ(lfl):NULL);
}
 
__parser__(flags=new)
MK_ATTR_RT_STATIC
mk_inline MK_LFL MkLogFileHandleResolve_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
) {
  return MkLfl(MkObjectHandleResolve(netHdl));
}
 
#define MkLogFileHandleResolve_e(netHdl) ({ \
  MK_HDL tmpHdl=netHdl; \
  MK_LFL tmp; \
  if (tmpHdl==0) { \
    tmp=NULL; \
  } else { \
    tmp=MkLogFileHandleResolve(tmpHdl); \
    if (tmp==NULL) { \
      MkErrorSetC_1_NULL("ERROR: 'MkLogFileC' handle is 'NULL'"); \
      goto error; \
    }; \
  }; \
  tmp; \
})
 
__parser__pop__;
 
// Class export & import
 
  __parser__(flags=new,doc-group=_ignore_,doc-index=Class,doc-name=Misc,class=MkLogFileC,null-return-allow)
  MK_ATTR_STATIC
  mk_inline MK_LFL MkLogFileGetNull ( void ) {
    return (MK_LFL)MK_NULL;
  }
// MkLogFileC - Misc - function
 
// MkLogFileC_Class_C_API
 
// END-MkLogFileS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=TOR);
 
__parser__(constructor,lng-constr)
MK_EXTERN enum MkErrorE MK_DECL
MkLogFileOpen_RT (
  MK_PARSER_RT
  MK_OBJ         errfmt     __parser__(argument,default=NULL),
  MK_STRN const  file,
  MK_LFL *      lfh_out
) MK_ATTR_RT_STATIC ;
 
__parser__(destructor)
MK_EXTERN void MK_DECL MkLogFileClose_RT (
  MK_PARSER_RT
  MK_LFL lfh
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // TOR
 
// MkLogFileC_TOR_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Write);
 
MK_EXTERN enum MkErrorE
MkLogFileWriteVL_RT (
  MK_PARSER_RT
  MK_LFLN lfl,
  MK_FST printfmt,
  va_list var_list
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE
MkLogFileWriteV_RT (
  MK_PARSER_RT
  MK_LFLN lfl,
  MK_FST printfmt,
  ...
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension)
MK_EXTERN enum MkErrorE
MkLogFileWriteC_RT (
  MK_PARSER_RT
  MK_LFLN lfl,
  MK_STRN text
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE
MkLogFileGetFile_RT (
  MK_PARSER_RT
  MK_LFLN lfl,
  MK_STRN *file_out
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // Write
 
// MkLogFileC_Write_C_API
 
// MkLogFileC_C_API
 
/* MARK_X ################################################################ */
/* ###                                                                 ### */
/* ###                 E X T E N S I O N - A P I                       ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
__parser__push__(doc-group=_ignore_);
 
__parser__(internal)
typedef struct MkExtensionS {
  // BEGIN-MkExtensionS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkExtensionS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  struct MkExtensionS  *next, *prev;      
} MkExtensionS;
 
// BEGIN-MkExtensionS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkExtensionC_SIGNATURE         (MkObjectC_SIGNATURE ^ (8u<<10))
  #define MkExtensionC_MASK              (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkExtensionC_X2ext(x)          (x)
  #define MkExtensionC_X2obj(x)          MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkExtensionS MkExtensionCR;
  __parser__(ignore) typedef const struct MkExtensionS MkExtensionCNR;
  #define MkExtensionC_T                 (&MK_RT_REF._MkExtensionC_T)
  #define MkExtensionC_TT                (MkTYP(MkExtensionC_T))
  #define MkExtensionST                  MkExtensionC_T
  #define MkExtensionSTT                 (MkTYP(MkExtensionST))
  #define MkExtensionC_type              MK_EXT
  #define MkExtensionCT_X(instance)      ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkExtensionCTT_X(instance)     (MkOBJ_R(instance).type)
  #define MkExtensionCT_TT(typ)          ( (struct MkSuperTypeS *) (typ) )
  #define MkExtensionC_NS                MK
  #define MkExtensionCTT                 MkExtensionCTT
  #define MkExtensionCT                  ( (struct MkSuperTypeS *) MkExtensionCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkExtensionC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkExtCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkExtensionC,mng);
  }
 
  __parser__(class=MkExtensionC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkExtCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkExtensionC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkExtensionC_Check(mng)        MkExtCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkExtensionC,ignore,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_EXT MkExt(MK_MNG mng) {
    return (MkExtCheck(mng) ? (MK_EXT)mng : NULL);
  }
 
  __parser__(class=MkExtensionC,ignore,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_EXTN MkExtN(MK_MNGN mng) {
    return (MkExtCheck(mng) ? (MK_EXTN)mng : NULL);
  }
 
  #define MkExtRaise(_ext) if (!_MkCheckX(MkExtensionC,_ext)) { \
    MkErrorSetC_1E("'MkExtensionC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkEXT_R(x)        (*(x)).super.ext
  #define   MkEXT(x)          (&MkEXT_R(x))
 
 
  __parser__pop__;
// MkExtensionC_Class_Define_C_API
 
// END-MkExtensionS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define MkExtension_size 64
 
__parser__(internal)
MK_EXTERN bool MK_DECL MkExtensionDeleteAll_RT (
  MK_PARSER_RT
  MK_EXT head
) MK_ATTR_RT_STATIC ;
 
__parser__(internal)
MK_EXTERN MK_EXT MK_DECL MkExtensionAdd_RT (
  MK_PARSER_RT
  MK_EXT head, 
  MK_EXT add
) MK_ATTR_RT_STATIC ;
 
__parser__(internal)
MK_EXTERN MK_EXT MK_DECL MkExtensionDel_RT (
  MK_PARSER_RT
  MK_EXT head, 
  MK_EXT del
) MK_ATTR_RT_STATIC ;
 
/*
//__parser__(internal)
//MK_EXTERN MK_EXT MK_DECL MkExtensionSearch (MK_EXT head, MK_TYP typ);
*/
 
__parser__pop__; // __parser__push__(doc-group=_ignore_);
 
// MkExtensionC_C_API
 
/* MARK_E ################################################################ */
/* ###                                                                 ### */
/* ###                     E R R O R - A P I                           ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
struct MkErrorS {
  // BEGIN-MkErrorS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkErrorS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // instance attributes
  enum MkErrorE       code;               
  struct MkBuffer1024S  text;             
  MK_I32              num;                
  bool                append;             
  bool                noRaise;            
 
  MK_OBJN             format_of_error;    
  MK_MNGN             source_of_error;    
 
  MK_ERREXT           mkErrExt;           
};
 
// BEGIN-MkErrorS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkErrorC_SIGNATURE             (MkObjectC_SIGNATURE ^ (4u<<10))
  #define MkErrorC_MASK                  (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkErrorC_X2err(x)              (x)
  #define MkErrorC_X2obj(x)              MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkErrorS MkErrorCR;
  __parser__(ignore) typedef const struct MkErrorS MkErrorCNR;
  #define MkErrorC_T                     (&MK_RT_REF._MkErrorC_T)
  #define MkErrorC_TT                    (MkTYP(MkErrorC_T))
  #define MkErrorST                      MkErrorC_T
  #define MkErrorSTT                     (MkTYP(MkErrorST))
  #define MkErrorC_type                  MK_ERR
  #define MkErrorCT_X(instance)          ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkErrorCTT_X(instance)         (MkOBJ_R(instance).type)
  #define MkErrorCT_TT(typ)              ( (struct MkSuperTypeS *) (typ) )
  #define MkErrorC_NS                    MK
  #define MkErrorCTT                     MkErrorCTT
  #define MkErrorCT                      ( (struct MkSuperTypeS *) MkErrorCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkErrorC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkErrCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkErrorC,mng);
  }
 
  __parser__(class=MkErrorC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkErrCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkErrorC,obj);
  }
 
  #pragma GCC diagnostic pop
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkErrorC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_ERR MkErr(MK_MNG mng) {
    return (MkErrCheck(mng) ? (MK_ERR)mng : NULL);
  }
 
  __parser__(class=MkErrorC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_ERRN MkErrN(MK_MNGN mng) {
    return (MkErrCheck(mng) ? (MK_ERRN)mng : NULL);
  }
 
  #define MkErrRaise(_err) if (!_MkCheckX(MkErrorC,_err)) { \
    MkErrorSetC_1E("'MkErrorC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkERR_R(x)        (*(x)).super.err
  #define   MkERR(x)          (&MkERR_R(x))
 
 
  __parser__pop__;
// MkErrorC_Class_Define_C_API
 
// END-MkErrorS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkErrorC_C_API
 
// =========================================================================
// BEGIN-MkErrorS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkErrorC);
 
__parser__(class-overload=MkObjectHandleGet)
MK_ATTR_RT_INSTANCE
mk_inline MK_HDL MK_DECL MkErrorHandleGet_RT ( 
  MK_PARSER_RT
  MK_ERR const err  __parser__(null-allowed)
) {
  return MkObjectHandleGet(err?MkOBJ(err):NULL);
}
 
__parser__(flags=new)
MK_ATTR_RT_STATIC
mk_inline MK_ERR MkErrorHandleResolve_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
) {
  return MkErr(MkObjectHandleResolve(netHdl));
}
 
#define MkErrorHandleResolve_e(netHdl) ({ \
  MK_HDL tmpHdl=netHdl; \
  MK_ERR tmp; \
  if (tmpHdl==0) { \
    tmp=NULL; \
  } else { \
    tmp=MkErrorHandleResolve(tmpHdl); \
    if (tmp==NULL) { \
      MkErrorSetC_1_NULL("ERROR: 'MkErrorC' handle is 'NULL'"); \
      goto error; \
    }; \
  }; \
  tmp; \
})
 
__parser__pop__;
 
// Class export & import
 
  __parser__(flags=new,doc-group=_ignore_,doc-index=Class,doc-name=Misc,class=MkErrorC,null-return-allow)
  MK_ATTR_STATIC
  mk_inline MK_ERR MkErrorGetNull ( void ) {
    return (MK_ERR)MK_NULL;
  }
// MkErrorC - Misc - function
 
// MkErrorC_Class_C_API
 
// END-MkErrorS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// #######################################################################
// -----------------------------------------------------------------------
 
#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
 
__parser__(ignore)
typedef bool (*MkErrorAppendFLT) (MK_ERREXT_ARGS, MK_OBJN const fmtobj);
 
__parser__(ignore)
typedef void (*MkErrorResetF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj);
 
__parser__(ignore)
typedef bool (*MkErrorResetOnExitF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj);
 
__parser__(ignore)
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);
 
__parser__(ignore)
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);
 
__parser__(ignore)
typedef MK_OBJN (*MkErrorFormatOfF) (MK_ERREXT_ARGS_N, int const dummy);
 
__parser__(ignore)
typedef void (*MkErrorSetRF) (MK_ERREXT_ARGS, MK_MNGN const errctx, MK_OBJN const fmtobj);
 
__parser__(ignore)
typedef void (*MkErrorSetEF) (MK_ERREXT_ARGS, MK_ERREXT const newerr, MK_OBJN const fmtobj);
 
__parser__(ignore)
typedef bool (*MkErrorSetVLF) (MK_ERREXT_ARGS, MK_OBJN const fmtobj, MK_STRN const);
 
__parser__(ignore)
typedef void (*MkErrorInit) (MK_ERREXT_ARGS, MK_OBJN const fmtobj);
 
__parser__(ignore)
struct MkErrExtS {
  // BEGIN-MkErrExtS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkExtensionS         ext;          // instance-base MkExtensionS
  } super;
 
  // END-MkErrExtS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  MK_ERR mkerrhead;
 
  MkErrorAppendFLT    fErrorAppend;
 
  MkErrorResetF     fErrorReset;
 
  MkErrorResetOnExitF     fErrorResetOnExit;
 
  MkErrorPanikF     fErrorPanik;
 
  MkErrorLogF       fErrorLog;
 
  MkErrorFormatOfF  fErrorFormatOf;
 
  MkErrorSetRF      fErrorSetR;
 
  MkErrorSetEF      fErrorSetE;
 
  MkErrorSetVLF     fErrorSetVL;
 
  MkErrorInit       fErrorInit;
};
 
// BEGIN-MkErrExtS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkErrExtC_SIGNATURE            (MkExtensionC_SIGNATURE ^ (1u<<6))
  #define MkErrExtC_MASK                 (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkErrExtC_X2errext(x)          (x)
  #define MkErrExtC_X2ext(x)             MkEXT(x)
  #define MkErrExtC_X2obj(x)             MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkErrExtS MkErrExtCR;
  __parser__(ignore) typedef const struct MkErrExtS MkErrExtCNR;
  #define MkErrExtC_T                    (&MK_RT_REF._MkErrExtC_T)
  #define MkErrExtC_TT                   (MkTYP(MkErrExtC_T))
  #define MkErrExtST                     MkErrExtC_T
  #define MkErrExtSTT                    (MkTYP(MkErrExtST))
  #define MkErrExtC_type                 MK_ERREXT
  #define MkErrExtCT_X(instance)         ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkErrExtCTT_X(instance)        (MkOBJ_R(instance).type)
  #define MkErrExtCT_TT(typ)             ( (struct MkSuperTypeS *) (typ) )
  #define MkErrExtC_NS                   MK
  #define MkErrExtCTT                    MkErrExtCTT
  #define MkErrExtCT                     ( (struct MkSuperTypeS *) MkErrExtCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkErrExtC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkErrExtCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkErrExtC,mng);
  }
 
  __parser__(class=MkErrExtC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkErrExtCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkErrExtC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkErrExtC_Check(mng)           MkErrExtCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkErrExtC,ignore,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_ERREXT MkErrExt(MK_MNG mng) {
    return (MkErrExtCheck(mng) ? (MK_ERREXT)mng : NULL);
  }
 
  __parser__(class=MkErrExtC,ignore,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_ERREXTN MkErrExtN(MK_MNGN mng) {
    return (MkErrExtCheck(mng) ? (MK_ERREXTN)mng : NULL);
  }
 
  #define MkErrExtRaise(_errext) if (!_MkCheckX(MkErrExtC,_errext)) { \
    MkErrorSetC_1E("'MkErrExtC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkERREXT_R(x)        (*(x)).super.errext
  #define   MkERREXT(x)          (&MkERREXT_R(x))
 
 
  __parser__pop__;
// MkErrExtC_Class_Define_C_API
 
// END-MkErrExtS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define MkErrExtAdd(_mkerrR,add) do {                      \
  (_mkerrR).mkErrExt = (typeof((_mkerrR).mkErrExt)) MkExtensionAdd(MkEXT((_mkerrR).mkErrExt),MkEXT(add));    \
  /* printV("MkErrExtAdd = %p, mkrt=%p\n", &(_mkerrR).mkErrExt, MK_RT_PTR); */ \
  MkERREXT_R(add).mkerrhead = &(_mkerrR);                  \
} while (0)                                                \
 
#define MkErrExtDel(_mkerrR,del) do {                      \
  /* printV("MkErrExtDel = %p, mkrt=%p\n", &(_mkerrR).mkErrExt, MK_RT_PTR); */ \
  (_mkerrR).mkErrExt = (typeof((_mkerrR).mkErrExt)) MkExtensionDel(MkEXT((_mkerrR).mkErrExt),MkEXT(del));    \
  MkERREXT_R(del).mkerrhead = NULL;                        \
} while (0)                                                \
 
// MkErrExtC_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__(ignore)
struct MkErrorPanicS {
  // BEGIN-MkErrorPanicS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkErrorPanicS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
};
 
// BEGIN-MkErrorPanicS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkErrorPanicC_SIGNATURE        (MkObjectC_SIGNATURE ^ (7u<<10))
  #define MkErrorPanicC_MASK             (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkErrorPanicC_X2obj(x)         MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkErrorPanicS MkErrorPanicCR;
  __parser__(ignore) typedef const struct MkErrorPanicS MkErrorPanicCNR;
  #define MkErrorPanicC_T                (&MK_RT_REF._MkErrorPanicC_T)
  #define MkErrorPanicC_TT               (MkTYP(MkErrorPanicC_T))
  #define MkErrorPanicST                 MkErrorPanicC_T
  #define MkErrorPanicSTT                (MkTYP(MkErrorPanicST))
  #define MkErrorPanicCT_X(instance)     ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkErrorPanicCTT_X(instance)    (MkOBJ_R(instance).type)
  #define MkErrorPanicCT_TT(typ)         ( (struct MkSuperTypeS *) (typ) )
  #define MkErrorPanicC_NS               MK
  #define MkErrorPanicCTT                MkErrorPanicCTT
  #define MkErrorPanicCT                 ( (struct MkSuperTypeS *) MkErrorPanicCTT )
 
 
  __parser__pop__;
// MkErrorPanicC_Class_Define_C_API
 
// END-MkErrorPanicS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkErrorPanicS_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__(ignore)
struct MkErrorIgnoreS {
  // BEGIN-MkErrorIgnoreS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkErrorIgnoreS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
};
 
// BEGIN-MkErrorIgnoreS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkErrorIgnoreC_SIGNATURE       (MkObjectC_SIGNATURE ^ (5u<<10))
  #define MkErrorIgnoreC_MASK            (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkErrorIgnoreC_X2obj(x)        MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkErrorIgnoreS MkErrorIgnoreCR;
  __parser__(ignore) typedef const struct MkErrorIgnoreS MkErrorIgnoreCNR;
  #define MkErrorIgnoreC_T               (&MK_RT_REF._MkErrorIgnoreC_T)
  #define MkErrorIgnoreC_TT              (MkTYP(MkErrorIgnoreC_T))
  #define MkErrorIgnoreST                MkErrorIgnoreC_T
  #define MkErrorIgnoreSTT               (MkTYP(MkErrorIgnoreST))
  #define MkErrorIgnoreCT_X(instance)    ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkErrorIgnoreCTT_X(instance)   (MkOBJ_R(instance).type)
  #define MkErrorIgnoreCT_TT(typ)        ( (struct MkSuperTypeS *) (typ) )
  #define MkErrorIgnoreC_NS              MK
  #define MkErrorIgnoreCTT               MkErrorIgnoreCTT
  #define MkErrorIgnoreCT                ( (struct MkSuperTypeS *) MkErrorIgnoreCTT )
 
 
  __parser__pop__;
// MkErrorIgnoreC_Class_Define_C_API
 
// END-MkErrorIgnoreS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkErrorIgnoreC_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__(ignore)
struct MkErrorPrintS {
  // BEGIN-MkErrorPrintS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkErrorPrintS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
};
 
// BEGIN-MkErrorPrintS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkErrorPrintC_SIGNATURE        (MkObjectC_SIGNATURE ^ (6u<<10))
  #define MkErrorPrintC_MASK             (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkErrorPrintC_X2obj(x)         MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkErrorPrintS MkErrorPrintCR;
  __parser__(ignore) typedef const struct MkErrorPrintS MkErrorPrintCNR;
  #define MkErrorPrintC_T                (&MK_RT_REF._MkErrorPrintC_T)
  #define MkErrorPrintC_TT               (MkTYP(MkErrorPrintC_T))
  #define MkErrorPrintST                 MkErrorPrintC_T
  #define MkErrorPrintSTT                (MkTYP(MkErrorPrintST))
  #define MkErrorPrintCT_X(instance)     ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkErrorPrintCTT_X(instance)    (MkOBJ_R(instance).type)
  #define MkErrorPrintCT_TT(typ)         ( (struct MkSuperTypeS *) (typ) )
  #define MkErrorPrintC_NS               MK
  #define MkErrorPrintCTT                MkErrorPrintCTT
  #define MkErrorPrintCT                 ( (struct MkSuperTypeS *) MkErrorPrintCTT )
 
 
  __parser__pop__;
// MkErrorPrintC_Class_Define_C_API
 
// END-MkErrorPrintS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
//MkErrorPrintC_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__(ignore)
struct MkErrorDefaultS {
  // BEGIN-MkErrorDefaultS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkErrorS             err;          // instance-base MkErrorS
  } super;
 
  // END-MkErrorDefaultS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
};
 
// BEGIN-MkErrorDefaultS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkErrorDefaultC_SIGNATURE      (MkErrorC_SIGNATURE ^ (1u<<6))
  #define MkErrorDefaultC_MASK           (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkErrorDefaultC_X2err(x)       MkERR(x)
  #define MkErrorDefaultC_X2obj(x)       MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkErrorDefaultS MkErrorDefaultCR;
  __parser__(ignore) typedef const struct MkErrorDefaultS MkErrorDefaultCNR;
  #define MkErrorDefaultC_T              (&MK_RT_REF._MkErrorDefaultC_T)
  #define MkErrorDefaultC_TT             (MkTYP(MkErrorDefaultC_T))
  #define MkErrorDefaultST               MkErrorDefaultC_T
  #define MkErrorDefaultSTT              (MkTYP(MkErrorDefaultST))
  #define MkErrorDefaultCT_X(instance)   ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkErrorDefaultCTT_X(instance)  (MkOBJ_R(instance).type)
  #define MkErrorDefaultCT_TT(typ)       ( (struct MkSuperTypeS *) (typ) )
  #define MkErrorDefaultC_NS             MK
  #define MkErrorDefaultCTT              MkErrorDefaultCTT
  #define MkErrorDefaultCT               ( (struct MkSuperTypeS *) MkErrorDefaultCTT )
 
 
  __parser__pop__;
// MkErrorDefaultC_Class_Define_C_API
 
// END-MkErrorDefaultS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkErrorDefaultC_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=System,class=MkErrorC);
 
#define   MkERROR_R(r)      ((*r).error_mk)
#define   MkERROR           MkERROR_R(&MK_RT_REF)
#define   MkERROR_RT        MkERROR_R(&MK_RT_REF)
#define   MkERROR_O(o)      MkERROR_R(MkRT_O(o))
#define   MkERROR_X(x)      MkERROR_R(MkRT_X(x))
#define   MkERROR_XN(x)     MkERROR_R(MkRT_XN(x))
#define   MkERROR_NULL      MkERROR_R(&MkRuntimeRLS)
 
 
#define MK_ERROR_DEFAULT_R(r)   MkOBJ(&(*r).error_mk)
#define MK_ERROR_DEFAULT        MK_ERROR_DEFAULT_R(&MK_RT_REF)
#define MK_ERROR_DEFAULT_X(x)   MK_ERROR_DEFAULT_R(MkRT_X(x))
#define MK_ERROR_DEFAULT_NULL   MK_ERROR_DEFAULT_R(&MkRuntimeRLS)
 
mk_inline MK_ERR MkErrorDEFAULT_RT ( MK_PARSER_RT_ONLY );
 
// END: MkErrorDEFAULT
 
 
#define MK_ERROR_PANIC_R(r)     MkOBJ(&(*r).error_panic)
#define MK_ERROR_PANIC          MK_ERROR_PANIC_R(&MK_RT_REF)
#define MK_ERROR_PANIC_X(x)     MK_ERROR_PANIC_R(MkRT_X(x))
#define MK_ERROR_PANIC_NULL     MK_ERROR_PANIC_R(&MkRuntimeRLS)
 
__parser__(hide)
mk_inline MK_ERR MkErrorPANIC_RT ( MK_PARSER_RT_ONLY );
 
// END: MkErrorPanik
 
 
#define MK_ERROR_IGNORE_R(r)    MkOBJ(&(*r).error_ignore)
#define MK_ERROR_IGNORE         MK_ERROR_IGNORE_R(&MK_RT_REF)
#define MK_ERROR_IGNORE_X(x)    MK_ERROR_IGNORE_R(MkRT_X(x))
#define MK_ERROR_IGNORE_XN(x)   MK_ERROR_IGNORE_R(MkRT_XN(x))
#define MK_ERROR_IGNORE_NULL    MK_ERROR_IGNORE_R(&MkRuntimeRLS)
 
mk_inline MK_ERR MkErrorIGNORE_RT ( MK_PARSER_RT_ONLY );
 
// MkErrorIgnore
 
 
#define MK_ERROR_PRINT_R(r)     MkOBJ(&(*r).error_print)
#define MK_ERROR_PRINT          MK_ERROR_PRINT_R(&MK_RT_REF)
#define MK_ERROR_PRINT_X(x)     MK_ERROR_PRINT_R(MkRT_X(x))
#define MK_ERROR_PRINT_NULL     MK_ERROR_PRINT_R(&MkRuntimeRLS)
 
mk_inline MK_ERR MkErrorPRINT_RT ( MK_PARSER_RT_ONLY );
 
// MkErrorPrintln
 
 
#define MK_ERROR_FORMAT_R(r)    ((*r).error_mk.format_of_error ? (*r).error_mk.format_of_error : \
                                  MkObjN((*r).error_mk.source_of_error) ? MkObjN((*r).error_mk.source_of_error) : \
                                    MK_ERROR_DEFAULT_R(r))
#define MK_ERROR_FORMAT         MK_ERROR_FORMAT_R(&MK_RT_REF)
#define MK_ERROR_FORMAT_X(x)    MK_ERROR_FORMAT_R(MkRT_X(x))
#define MK_ERROR_FORMAT_NULL    MK_ERROR_FORMAT_R(&MkRuntimeRLS)
 
MK_EXTERN MK_ERR MK_DECL MkErrorFORMAT ( 
  MK_PARSER_fmtobj
) MK_ATTR_STATIC ;
 
#define MkErrorFORMAT_1M(m)  MkErrorFORMAT(MkObjN(m))
#define MkErrorFORMAT_1X(x)  MkErrorFORMAT(MkOBJ(x))
#define MkErrorFORMAT_1O(o)  MkErrorFORMAT(o)
 
__parser__(internal)
MK_EXTERN MK_ERR MK_DECL MkErrorFORMAT_EO ( 
  MK_PARSER_fmtobj      
) MK_ATTR_STATIC ;
 
 
__parser__pop__;
 
// END: MkErrorC_System_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=TOR);
 
__parser__(destructor)
MK_EXTERN void MK_DECL MkErrorDelete_RT (
  MK_PARSER_RT
  MK_ERR err
) MK_ATTR_RT_INSTANCE;
 
__parser__(constructor)
MK_EXTERN MK_ERR MK_DECL MkErrorDup_RT (
  MK_PARSER_RT
  MK_ERRN const srce
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // TOR
 
// MkErrorC_TOR_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Get);
 
__parser__(error-ignore,inline=MkErrorGetCodeI)
MK_EXTERN enum MkErrorE MK_DECL MkErrorGetCode (
  MK_ERRN const err
) MK_ATTR_INSTANCE;
 
#define MkErrorGetCodeI(e)  ((*e).code)
#define MkErrorGetCodeE_NULL()  (MkERROR_NULL.code)
#define MkErrorGetCode_O(o) (MkERROR_O(o).code)
 
__parser__(inline=MkErrorGetTextI)
MK_EXTERN MK_STRN MK_DECL MkErrorGetText (
  MK_ERRN const err
) MK_ATTR_INSTANCE;
 
#define MkErrorGetTextI(e)  (MkBUF_R(&(*e).text).storage.first.C)
 
__parser__(inline=MkErrorGetSizeI)
MK_EXTERN MK_SIZE MK_DECL MkErrorGetSize (
  MK_ERRN const err
) MK_ATTR_INSTANCE;
 
#define MkErrorGetSizeI(e)    ((MK_SIZE)MkBUF_R(&(*e).text).var.cursize)
 
__parser__(inline=MkErrorGetNumI)
MK_EXTERN MK_I32 MK_DECL MkErrorGetNum (
  MK_ERRN const err
) MK_ATTR_INSTANCE;
 
#define MkErrorGetNumI(e)   ((*e).num)
 
__parser__pop__;
 
// MkErrorC_Get_C_API
 
/*****************************************************************************/
/*                                                                           */
/*                              error set                                    */
/*                                                                           */
/*****************************************************************************/
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Signal);
 
MK_EXTERN void MK_DECL MkErrorSetCONTINUE_RT (
  MK_PARSER_RT
  MK_ERR const  err
) MK_ATTR_RT_INSTANCE;
 
#define MkErrorSetCONTINUE_0E()     MkErrorSetCONTINUE(&MkERROR)
 
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetEXIT_RT (
  MK_PARSER_RT
  MK_ERR  const  err,
  MK_STRN const  callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetSOCKET_RT (
  MK_PARSER_RT
  MK_ERR  const  err,
  MK_STRN const  detail      __parser__(default=S#"UNKNOWN"),
  MK_STRN const  callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetABORT_RT (
  MK_PARSER_RT
  MK_ERR  const  err,
  MK_STRN const  detail      __parser__(default=S#"UNKNOWN"),
  MK_STRN const  callfunc    __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN void MK_DECL MkErrorSetCode_RT (
  MK_PARSER_RT
  MK_ERR const    err,
  enum MkErrorE   code
) MK_ATTR_RT_INSTANCE;
 
MK_EXTERN bool MK_DECL MkErrorIsSOCKET (
  MK_ERRN const    err
) MK_ATTR_INSTANCE;
 
MK_EXTERN bool MK_DECL MkErrorIsABORT (
  MK_ERRN const    err
) MK_ATTR_INSTANCE;
 
MK_EXTERN bool MK_DECL MkErrorIsTIMEOUT (
  MK_ERRN const    err
) MK_ATTR_INSTANCE;
 
MK_EXTERN bool MK_DECL MkErrorIsEXIT (
  MK_ERR const    err
) MK_ATTR_INSTANCE;
 
__parser__pop__; // Signal
 
// MkErrorC_Signal_C_API
 
/*****************************************************************************/
/*                                                                           */
/*                              error_is/check                               */
/*                                                                           */
/*****************************************************************************/
 
 
#define MkErrorCheckI(err)  ((err) >= MK_ERROR)
#define MkErrorCheckE_0E()    (MkErrorCheckI(MkErrorGetCode_0E()))
#define MkErrorCheckE_NULL()  (MkErrorCheckI(MkErrorGetCodeE_NULL()))
#define MkErrorCheckE_O(o)    (MkErrorCheckI(MkErrorGetCode_O(o)))
#define MkErrorCheckE_X(x)    MkErrorCheckE_O(MkOBJ(x))
#define MkErrorCheck(err)   if (MkErrorCheckI(err))   goto error
#define MkErrorE_Check(err) if (MkErrorCheckI(err))   goto error
#define MkErrorCheck_0E()   if (MkErrorCheckE_0E())   goto error
#define MkErrorBreak(err)   if (MkErrorCheckI(err))   break
#define MkContinueCheck(err)  switch (err) { \
case MK_OK: break; case MK_CONTINUE: goto cont; case MK_ERROR: goto error;\
};
 
#define MkErrorSwitch(PROC) switch (PROC) {\
case MK_OK: break; case MK_ERROR: goto error; case MK_CONTINUE: return MK_CONTINUE;\
}
 
/*
OLD and unused
 
#define MkErrorReturnAppend(PROC)    \
if (MkErrorCheckI(PROC)) {           \
  return MkErrorStack_0E ();         \
} else if (MkErrorCheckE_0E()) {     \
  return MkErrorReset_0E ();         \
} else {                             \
  return MkERROR.code;               \
}
*/
#define MkErrorReturn_2X(mngx,PROC) switch (PROC) {\
case MK_OK: return MK_OK; case MK_CONTINUE: return MK_CONTINUE; default: return MkErrorStack_1X (mngx);\
};
#define MkErrorReturn_1(PROC) switch (PROC) {\
case MK_OK: return MK_OK; case MK_CONTINUE: return MK_CONTINUE; default: return MkErrorStack_0E ();\
};
#define MkErrorReturn(PROC) MkErrorReturn_2X(META_CONTEXT_S,PROC)
#define check_MkErrorE(PROC) if (MkErrorCheckI(PROC))
 
#define MkErrorReturnLabel(mng) \
  return MK_OK; \
error: \
  return MkErrorStack_1M(mng);
 
// MkErrorCheck...
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__global__(prefix2class:MkPanic=MkErrorC);
__parser__push__(doc-group=Raise);
 
MK_EXTERN void MK_DECL MkPanicVL_RT (
  MK_PARSER_RT
  MK_OBJN const         errfmt      __parser__(default=F#ERROR_FORMAT),
  MK_STRN const         callfunc    __parser__(default=F#FUNC),
  MK_I32 const          errnum      __parser__(default=-1),
  MK_FST const          printfmt,
  va_list               var_list
) MK_ATTR_RT_INSTANCE __attribute__((noreturn));
 
#define MkPanicVL_5M(errobj,callfunc,errnum,printfmt,var_list)  \
        MkPanicVL(MkObj(errobj),callfunc,errnum,printfmt,var_list)
 
MK_EXTERN void MK_DECL MkPanicV_RT (
  MK_PARSER_RT
  MK_OBJN const errfmt    __parser__(default=F#ERROR_FORMAT),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const errnum    __parser__(default=-1),
  MK_FST  const printfmt,
  ...
) MK_ATTR_RT_INSTANCE MK_RT_ATTR_FORMAT_4 __attribute__((noreturn));
 
#define MkPanicV_4M(errobj,callfunc,errnum,printfmt,...) \
          MkPanicV(MkObj(errobj),callfunc,errnum,printfmt,__VA_ARGS__)
 
#define MkPanicV_2M(x,printfmt,...) \
          MkPanicV_2(MkObj(x),printfmt,__VA_ARGS__)
 
__parser__(no-type-extension,no-rpc)
MK_EXTERN void MK_DECL MkPanicC_RT (
  MK_PARSER_RT
  MK_OBJN const errfmt    __parser__(default=F#ERROR_FORMAT),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const errnum    __parser__(default=-1),
  MK_STRN const message
) MK_ATTR_RT_INSTANCE __attribute__ ((noreturn));
 
#define MkPanicC_4M(errobj,callfunc,errnum,message) \
          MkPanicC(MkObj(errobj),callfunc,errnum,message)
 
#define MkPanicC_2M(x,message)  MkPanicC_2(MkObj(x),message)
 
#define MkPanicSYS(mngx) do {                                             \
  MkLogC_2X(mngx,"internal ERROR, please contact your local support\n");  \
  MkDisasterSignal(-1);                                                   \
} while (0)
 
__parser__(internal,overload-c-no)
MK_EXTERN void MK_DECL MkDisasterSignal (
  MK_I32 signal    __parser__(default=-1)      // NO signal
) __attribute__ ((noreturn));
 
MK_EXTERN void MK_DECL MkErrorAppendVL_RT (
  MK_PARSER_RT
  MK_ERR const err,
  MK_FST const printfmt,
  va_list var_list
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension)
MK_EXTERN void MK_DECL MkErrorAppendV_RT (
  MK_PARSER_RT
  MK_ERR const err,
  MK_FST const printfmt,
  ...
) MK_ATTR_RT_INSTANCE MK_RT_ATTR_FORMAT_2;
 
__parser__(no-type-extension)
MK_EXTERN void MK_DECL MkErrorAppendC_RT (
  MK_PARSER_RT
  MK_ERR const err,
  MK_STRN const message
) MK_ATTR_RT_INSTANCE;
 
__parser__(doc-group=Raise)
MK_EXTERN MK_ERR MK_DECL MkErrorNoRaise_RT (
  MK_PARSER_RT
  MK_ERR const err
) MK_ATTR_RT_INSTANCE;
 
__parser__(internal)
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetR_RT (
  MK_PARSER_RT
  MK_ERR const          err,
  MK_STRN const         message,
  enum MkErrorE const   errcode     __parser__(default=F#MK_ERROR),
  MK_I32 const          errnum      __parser__(default=-1),
  MK_MNG const          errctx      __parser__(default=NULL)
) MK_ATTR_RT_INSTANCE;
 
__parser__(hide)
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetE_RT (
  MK_PARSER_RT
  MK_ERR const          err,
  MK_ERR const          newerr
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension)
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetC_RT (
  MK_PARSER_RT
  MK_ERR        err,
  MK_STRN const message,
  MK_STRN const callfunc    __parser__(default=F#FUNC),
  MK_I32  const errnum      __parser__(default=-1)
) MK_ATTR_RT_INSTANCE;
 
#define MkErrorSetC_1XS(message)            MkErrorSetC_4M(META_CONTEXT_S,message,__func__,-1)
#define MkErrorSetC_2E_E(caller,message)    MkErrorCheck(MkErrorSetC_2E(message,caller))
 
#define MkErrorSetC_4_NULL(...)             MkErrorSetC_RT(MK_RT_NULL __VA_ARGS__)
#define MkErrorSetC_3_NULL(...)             MkErrorSetC_4_NULL(&MkERROR_NULL,__VA_ARGS__)
#define MkErrorSetC_2_NULL(msg,pfx)         MkErrorSetC_3_NULL(msg,pfx,-1)
#define MkErrorSetC_1_NULL(msg)             MkErrorSetC_3_NULL(msg,__func__,-1)
 
#define MkErrorSetC_4M_NULL(m,...)          MkErrorSetC_4_NULL(MkErrorFORMAT_1M(m),__VA_ARGS__)
#define MkErrorSetC_3M_NULL(m,msg,pfx)      MkErrorSetC_4M_NULL(m,msg,pfx,-1)
#define MkErrorSetC_2M_NULL(m,msg)          MkErrorSetC_4M_NULL(m,msg,__func__,-1)
 
__parser__(no-type-extension)
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetVL_RT (
  MK_PARSER_RT
  MK_ERR          err,
  MK_STRN  const  callfunc    __parser__(default=F#FUNC),
  MK_I32   const  errnum      __parser__(default=-1),
  MK_FST   const  printfmt,
  va_list         var_list
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-type-extension)
MK_EXTERN enum MkErrorE MK_DECL MkErrorSetV_RT (
  MK_PARSER_RT
  MK_ERR         err,
  MK_STRN const  callfunc   __parser__(default=F#FUNC),
  MK_I32  const  errnum     __parser__(default=-1),
  MK_FST  const  printfmt,
  ...
) MK_ATTR_RT_INSTANCE MK_RT_ATTR_FORMAT_4;
 
#define MkErrorSetV_4EO_NULL(o,...)  MkErrorSetV_NULL(MkErrorFORMAT_EO(o), __VA_ARGS__)
#define MkErrorSetV_4M_NULL(m,...)   MkErrorSetV_NULL(MkErrorFORMAT_1M(m),__VA_ARGS__)
#define MkErrorSetV_2M_NULL(m,...)   MkErrorSetV_4M_NULL(m,__func__,-1,__VA_ARGS__)
#define MkErrorSetV_2X(x,...)        MkErrorSetV(MkErrorFORMAT_1X(x),__func__,-1,__VA_ARGS__)
 
#define MkErrorSetV_1_NULL(printfmt,...) \
          MkErrorSetV_NULL(&MkERROR_NULL,__func__,-1,printfmt,__VA_ARGS__)
 
#define MkErrorSetV_1XS(printfmt,...) \
          MkErrorSetV_4M(META_CONTEXT_S,__func__,-1,printfmt,__VA_ARGS__)
 
#define MkErrorSetV_2E_E(caller,printfmt,...) \
          MkErrorCheck(MkErrorSetV_2E(caller,printfmt,__VA_ARGS__))
 
#define MkErrorSet_ObjectIsNullError(m,printfmt,...) \
          MkErrorSetV_4M(m,"ObjectIsNullError",-1,printfmt,__VA_ARGS__)
 
#define MkErrorSysO(obj,cmd) \
  MkErrorSetV_4EO_NULL (obj, __func__, errno, \
    "can not '%s' -> ERR<%s>", MK_CPPXSTR(cmd), strerror (errno))
 
__parser__pop__; // Raise
 
// MkErrorC_Raise_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Misc);
 
MK_EXTERN void MK_DECL MkErrorPrintln_RT (
  MK_PARSER_RT
  MK_ERR const err
) MK_ATTR_RT_INSTANCE;
 
#define MkErrorPrintln_0()     MkErrorPrintln_0E()
 
__parser__(const,class-overload=MkObjectLog)
MK_EXTERN void MK_DECL MkErrorLog_RT (
  MK_PARSER_RT
  MK_ERRN const err       ,
  MK_PARSER_fmtobj        ,
  MK_DBG  const debug     __parser__(default=0),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
#define MkErrorLog_1EF_NULL(fmt)   MkErrorLog(&MkERROR_NULL,MkObj(fmt),0,__func__,0)
 
__parser__(no-rpc,template-overload)
MK_EXTERN MK_ERR MK_DECL MkErrorCatch_RT (
  MK_PARSER_RT
  MK_ERR  const  err,
  MK_EXP  const  exception  __parser__(default=NULL,has-reference),
  MK_STRN const  callfunc   __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
__parser__(no-rpc,template-overload)
MK_EXTERN MK_ERR MK_DECL MkObjectErrorCatch_RT (
  MK_PARSER_RT
  MK_OBJN const  obj,
  MK_EXP  const  exception  __parser__(default=NULL,has-reference),
  MK_STRN const  callfunc   __parser__(default=F#FUNC)
) MK_ATTR_RT_INSTANCE;
 
#define MkObjectErrorCatch_3X(x,...) MkObjectErrorCatch(MkOBJ(x),__VA_ARGS__)
 
__parser__(doc-group=Raise)
MK_EXTERN enum MkErrorE MK_DECL MkErrorRaise_RT (
  MK_PARSER_RT
  MK_ERRN const err
) MK_ATTR_RT_INSTANCE;
 
// [MkErrorReset-example]
MK_EXTERN enum MkErrorE MK_DECL MkErrorReset_RT (
  MK_PARSER_RT
  MK_ERR  const err,
  MK_STRN const callfunc __parser__(default=F#FUNC),
  MK_I32  const callline __parser__(default=F#LINE),
  bool    const force    __parser__(default=B#false)
) MK_ATTR_RT_INSTANCE;
 
#define MkErrorReset_0M()       MkErrorReset_4M(NULL,__func__,__LINE__,0);
#define MkErrorResetFORCE(m)    MkErrorReset_4M(m,__func__,__LINE__,1);
 
#define MkErrorReset_4X(x,...)  MkErrorReset(MkErrorFORMAT_1X(x),__VA_ARGS__)
#define MkErrorReset_1X(x)      MkErrorReset_4X(x,__func__,__LINE__,0)
// [MkErrorReset-example]
 
MK_EXTERN void
MK_DECL MkErrorStackFormat_RT (
  MK_PARSER_RT
  MK_ERR const    err,
  MK_STRN         callfunc    __parser__(default=F#FUNC),
  MK_STRN         callfile    __parser__(default=F#FILE),
  MK_I32 const    callline    __parser__(default=F#LINE)
) MK_ATTR_RT_INSTANCE;
 
__parser__(error-ignore,no-rpc)
MK_EXTERN enum MkErrorE
MK_DECL MkErrorStack_RT (
  MK_PARSER_RT
  MK_ERR  const err         __parser__(default=NULL),
  MK_STRN const callfunc    __parser__(default=F#FUNC),
  MK_STRN const callfile    __parser__(default=F#FILE),
  MK_I32  const callline    __parser__(default=F#LINE)
) MK_ATTR_RT_INSTANCE ;
 
#define MkErrorStack_1M_Check(m)        (MkErrorCheckE_0E() ? MkErrorStack_1M(m) : MkErrorGetCode_0E())
#define MkErrorStack_0E_Check()         (MkErrorCheckE_0E() ? MkErrorStack_0E() : MkErrorGetCode_0E())
 
#define MkErrorStack_4X(x,...)          MkErrorStack_RT(MK_RT_CALL MkErrorFORMAT_1X(x),__VA_ARGS__)
#define MkErrorStack_3X(...)            MkErrorStack_4X(__VA_ARGS__,__LINE__)
#define MkErrorStack_2X(...)            MkErrorStack_4X(__VA_ARGS__,__FILE__,__LINE__)
#define MkErrorStack_1X(...)            MkErrorStack_4X(__VA_ARGS__,__func__,__FILE__,__LINE__)
 
#define MkErrorStack_0_NULL()           MkErrorStack_NULL(&MkERROR_NULL,__func__,__FILE__,__LINE__)
 
#define MkErrorStack_4X_NULL(x,...)     MkErrorStack_NULL(MkErrorFORMAT_1X(x),__VA_ARGS__)
#define MkErrorStack_3X_NULL(...)       MkErrorStack_4X_NULL(__VA_ARGS__,__LINE__)
#define MkErrorStack_2X_NULL(...)       MkErrorStack_4X_NULL(__VA_ARGS__,__FILE__,__LINE__)
#define MkErrorStack_1X_NULL(...)       MkErrorStack_4X_NULL(__VA_ARGS__,__func__,__FILE__,__LINE__)
 
#define MkErrorStack_NUM    50
#define MkErrorStack_STR    "50"
 
__parser__(class-overload=MkObjectToString)
MK_EXTERN MK_STRN
MK_DECL MkErrorToString_RT (
  MK_PARSER_RT
  MK_ERRN const inst
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__; // Misc
 
// MkErrorC_Misc_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__(class=MkExceptionC,ignore)
bool MkExceptionCheck (MK_EXP exception);
 
__parser__(class=MkExceptionC,ignore)
void MkExceptionRaise (
  MK_MNG const expobj,
  MK_STRN const callfunc,
  MK_I32 const callline
) ;
 
__parser__(class=MkExceptionC,ignore)
MK_ERR MkExceptionCatch (
  MK_MNG const expobj,
  MK_EXP const exception,
  MK_STRN const callfunc
) ;
 
// MkException_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__(ignore)
struct MkRtExtS {
  // BEGIN-MkRtExtS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
    struct MkExtensionS         ext;          // instance-base MkExtensionS
  } super;
 
  // END-MkRtExtS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  MK_RT mkrtHead;
};
 
// BEGIN-MkRtExtS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkRtExtC_SIGNATURE             (MkExtensionC_SIGNATURE ^ (2u<<6))
  #define MkRtExtC_MASK                  (((1u<<26)-1)<<6)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkRtExtC_X2rtext(x)            (x)
  #define MkRtExtC_X2ext(x)              MkEXT(x)
  #define MkRtExtC_X2obj(x)              MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkRtExtS MkRtExtCR;
  __parser__(ignore) typedef const struct MkRtExtS MkRtExtCNR;
  #define MkRtExtC_T                     (&MK_RT_REF._MkRtExtC_T)
  #define MkRtExtC_TT                    (MkTYP(MkRtExtC_T))
  #define MkRtExtST                      MkRtExtC_T
  #define MkRtExtSTT                     (MkTYP(MkRtExtST))
  #define MkRtExtC_type                  MK_RTEXT
  #define MkRtExtCT_X(instance)          ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkRtExtCTT_X(instance)         (MkOBJ_R(instance).type)
  #define MkRtExtCT_TT(typ)              ( (struct MkSuperTypeS *) (typ) )
  #define MkRtExtC_NS                    MK
  #define MkRtExtCTT                     MkRtExtCTT
  #define MkRtExtCT                      ( (struct MkSuperTypeS *) MkRtExtCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkRtExtC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkRtExtCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkRtExtC,mng);
  }
 
  __parser__(class=MkRtExtC,static,ignore)
  MK_ATTR_STATIC
  mk_inline bool MkRtExtCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkRtExtC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkRtExtC_Check(mng)            MkRtExtCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkRtExtC,ignore,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_RTEXT MkRtExt(MK_MNG mng) {
    return (MkRtExtCheck(mng) ? (MK_RTEXT)mng : NULL);
  }
 
  __parser__(class=MkRtExtC,ignore,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_RTEXTN MkRtExtN(MK_MNGN mng) {
    return (MkRtExtCheck(mng) ? (MK_RTEXTN)mng : NULL);
  }
 
  #define MkRtExtRaise(_rtext) if (!_MkCheckX(MkRtExtC,_rtext)) { \
    MkErrorSetC_1E("'MkRtExtC' hdl is NULL"); \
    goto error ; \
  }
 
  #define   MkRTEXT_R(x)        (*(x)).super.rtext
  #define   MkRTEXT(x)          (&MkRTEXT_R(x))
 
 
  __parser__pop__;
// MkRtExtC_Class_Define_C_API
 
// END-MkRtExtS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define MkRtExtAdd(_mkrtR,add,id) do {                   \
  (_mkrtR).mkRtExt = (typeof((_mkrtR).mkRtExt)) MkExtensionAdd(MkEXT((_mkrtR).mkRtExt),MkEXT(add));    \
  MkRTEXT_R(add).mkrtHead = &(_mkrtR);                   \
  (_mkrtR).mkRtExtAry[id] = MkRTEXT(add);                \
} while (0)                                              \
 
#define MkRtExtDel(_mkrtR,del,id) do {                   \
  (_mkrtR).mkRtExt = (typeof((_mkrtR).mkRtExt)) MkExtensionDel(MkEXT((_mkrtR).mkRtExt),MkEXT(del));    \
  MkRTEXT_R(del).mkrtHead = NULL;                        \
  (_mkrtR).mkRtExtAry[id] = NULL;                        \
} while (0)                                              \
 
// MkRtExtC_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
//
// \addtogroup MqExceptionC_C_API
// \{
// \brief  target-language class to 'set' and 'raise' an error …
//
// \} 
// MqExceptionC_C_API
 
/* MARK_R ################################################################ */
/* ###                                                                 ### */
/* ###                   R U N T I M E - A P I                         ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
__parser__global__(prefix2class:MkRuntime=MkRuntimeC);
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlto-type-mismatch"
 
#if defined(MK_C_BUILD_DLL)
 
  #define   META_SECTION_DEFINE
  #include "MkRuntimeS_mk.h"
  #undef    META_SECTION_DEFINE
 
#else
 
struct MkRuntimeS {
 
  // ======================================================================================
  // PUBLIC variables -> sync with MkRuntimeS_mk.h !!
 
  // !!! sync with MkRuntimeS_mk.h
 
 
  // BEGIN-MkRuntimeS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  union {
    struct MkObjectS            obj;          // instance-base MkObjectS
  } super;
 
  // END-MkRuntimeS-super - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  struct MkErrorS         error_mk;
 
  struct MkErrorPanicS    error_panic;
 
  struct MkErrorIgnoreS   error_ignore;
 
  struct MkErrorPrintS    error_print;
 
  // instance attributes
  MK_RTEXT   rtHead;
 
 
    bool                isSilent;
 
    bool                noDeco;
 
    MK_I32              debug;
 
    FILE                *logFILE;
 
    MK_STR              logfile;
    bool                logfileLOCK;
 
 
  struct MkBuffer64S    bud;
 
  MK_PTR              threadData;
 
  MK_RTEXT            mkRtExt;
  MK_RTEXT            mkRtExtAry[MkExtension_size];
 
  MkSelfIncrF         fSelfIncr;
 
  MkSelfDecrF         fSelfDecr;
 
  bool                MkSelfIncrOnCacheB;
 
  // ======================================================================================
  // TYPES
 
  // BEGIN-rtDef - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  struct  MkSuperTypeS     _MkObjectC_T             ;
  struct  MkSuperTypeS     _MkBufferC_T             ;
  struct  MkSuperTypeS     _MkBuffer64C_T           ;
  struct  MkSuperTypeS     _MkBuffer256C_T          ;
  struct  MkSuperTypeS     _MkBuffer1024C_T         ;
  struct  MkSuperTypeS     _MkBufferStreamC_T       ;
  struct  MkSuperTypeS     _MkBufferStream16384C_T  ;
  struct  MkSuperTypeS     _MkBufferStream256C_T    ;
  struct  MkSuperTypeS     _MkBufferStream64C_T     ;
  struct  MkSuperTypeS     _MkBufferStream1024C_T   ;
  struct  MkSuperTypeS     _MkBufferListC_T         ;
  struct  MkSuperTypeS     _MkLogFileC_T            ;
  struct  MkSuperTypeS     _MkErrorC_T              ;
  struct  MkSuperTypeS     _MkErrorDefaultC_T       ;
  struct  MkSuperTypeS     _MkErrorIgnoreC_T        ;
  struct  MkSuperTypeS     _MkErrorPrintC_T         ;
  struct  MkSuperTypeS     _MkErrorPanicC_T         ;
  struct  MkSuperTypeS     _MkExtensionC_T          ;
  struct  MkSuperTypeS     _MkErrExtC_T             ;
  struct  MkSuperTypeS     _MkRtExtC_T              ;
  struct  MkSuperTypeS     _MkRuntimeC_T            ;
  struct  MkTypeS          _MkTypeC_TT              ;
  struct  MkTypeS          _MkSuperTypeC_TT         ;
 
  // END-rtDef - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // offset calculated by "Nhi1InternalSize"
  MK_BINB private_variables[12986];
};
 
#endif
 
#pragma GCC diagnostic pop
 
// BEGIN-MkRuntimeS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  __parser__push__(prefix=Class, doc-group=Define, doc-index=Class);
 
// Signature --------------------------------------------------------------
 
  #define MkRuntimeC_SIGNATURE           (MkObjectC_SIGNATURE ^ (9u<<10))
  #define MkRuntimeC_MASK                (((1u<<22)-1)<<10)
 
 
// CompileTimeCast --------------------------------------------------------------
 
  #define MkRuntimeC_X2rt(x)             (x)
  #define MkRuntimeC_X2obj(x)            MkOBJ(x)
 
 
// TypeDef --------------------------------------------------------------
 
  __parser__(ignore) typedef struct MkRuntimeS MkRuntimeCR;
  __parser__(ignore) typedef const struct MkRuntimeS MkRuntimeCNR;
  #define MkRuntimeC_T                   (&MK_RT_REF._MkRuntimeC_T)
  #define MkRuntimeC_TT                  (MkTYP(MkRuntimeC_T))
  #define MkRuntimeST                    MkRuntimeC_T
  #define MkRuntimeSTT                   (MkTYP(MkRuntimeST))
  #define MkRuntimeC_type                MK_RT
  #define MkRuntimeCT_X(instance)        ( (struct MkSuperTypeS *) (MkOBJ_R(instance).type) )
  #define MkRuntimeCTT_X(instance)       (MkOBJ_R(instance).type)
  #define MkRuntimeCT_TT(typ)            ( (struct MkSuperTypeS *) (typ) )
  #define MkRuntimeC_NS                  MK
  #define MkRuntimeCTT                   MkRuntimeCTT
  #define MkRuntimeCT                    ( (struct MkSuperTypeS *) MkRuntimeCTT )
 
 
// TypeCheck --------------------------------------------------------------
 
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wattributes"
 
  __parser__(class=MkRuntimeC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkRtCheck (MK_MNGN mng) {
    return MkSanitizeCheck(MkRuntimeC,mng);
  }
 
  __parser__(class=MkRuntimeC,static,hide)
  MK_ATTR_STATIC
  mk_inline bool MkRtCheckO (MK_OBJN obj) {
    return MkSanitizeCheckO(MkRuntimeC,obj);
  }
 
  #pragma GCC diagnostic pop
  #define MkRuntimeC_Check(mng)          MkRtCheck(mng)
 
 
// RunTimeCast --------------------------------------------------------------
 
  __parser__(class=MkRuntimeC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_RT MkRt(MK_MNG mng) {
    return (MkRtCheck(mng) ? (MK_RT)mng : NULL);
  }
 
  __parser__(class=MkRuntimeC,hide,static)
  META_ATTRIBUTE_SANITIZE
  MK_ATTR_STATIC
  mk_inline MK_RTN MkRtN(MK_MNGN mng) {
    return (MkRtCheck(mng) ? (MK_RTN)mng : NULL);
  }
 
  #define MkRtRaise(_rt) if (!_MkCheckX(MkRuntimeC,_rt)) { \
    MkErrorSetC_1E("'MkRuntimeC' hdl is NULL"); \
    goto error ; \
  }
 
 
  __parser__pop__;
// MkRuntimeC_Class_Define_C_API
 
// END-MkRuntimeS-Definition - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// MkRuntime_C_API
 
// =========================================================================
// BEGIN-MkRuntimeS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
 
__parser__push__(doc-group=_ignore_,doc-index=Class,doc-name=Export,class=MkRuntimeC);
 
__parser__(class-overload=MkObjectHandleGet)
MK_ATTR_RT_INSTANCE
mk_inline MK_HDL MK_DECL MkRuntimeHandleGet_RT ( 
  MK_PARSER_RT
  MK_RT const rt  __parser__(null-allowed)
) {
  return MkObjectHandleGet(rt?MkOBJ(rt):NULL);
}
 
__parser__(flags=new)
MK_ATTR_RT_STATIC
mk_inline MK_RT MkRuntimeHandleResolve_RT (
  MK_PARSER_RT
  MK_HDL const netHdl 
) {
  return MkRt(MkObjectHandleResolve(netHdl));
}
 
#define MkRuntimeHandleResolve_e(netHdl) ({ \
  MK_HDL tmpHdl=netHdl; \
  MK_RT tmp; \
  if (tmpHdl==0) { \
    tmp=NULL; \
  } else { \
    tmp=MkRuntimeHandleResolve(tmpHdl); \
    if (tmp==NULL) { \
      MkErrorSetC_1_NULL("ERROR: 'MkRuntimeC' handle is 'NULL'"); \
      goto error; \
    }; \
  }; \
  tmp; \
})
 
__parser__pop__;
 
// Class export & import
 
  __parser__(flags=new,doc-group=_ignore_,doc-index=Class,doc-name=Misc,class=MkRuntimeC,null-return-allow)
  MK_ATTR_STATIC
  mk_inline MK_RT MkRuntimeGetNull ( void ) {
    return (MK_RT)MK_NULL;
  }
// MkRuntimeC - Misc - function
 
// MkRuntimeC_Class_C_API
 
// END-MkRuntimeS-Export - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__global__(MkRuntimeHandleGet:hide);
__parser__global__(MkRuntimeHandleResolve:hide);
__parser__global__(MkRuntimeGetNull:hide);
 
// #######################################################################
// -----------------------------------------------------------------------
 
 
#define   MkRT                      (&MkRuntimeRLS)
#define   MkRT_R                    (MkRuntimeRLS)
 
#if META_HAS_THREAD
  #define   MkRT_O(o)               ((o) && (*o).objRt       ? (*o).objRt       : MkRuntimeGet())
  #define   MkRT_X(x)               ((x) && MkOBJ_R(x).objRt ? MkOBJ_R(x).objRt : MkRuntimeGet())
  #define   MkRT_ONN(o)             ((*o).objRt)
  #define   MkRT_ON(o)              (       (*o).objRt       ? (*o).objRt       : MkRuntimeGet())
  #define   MkRT_XN(x)              (       MkOBJ_R(x).objRt ? MkOBJ_R(x).objRt : MkRuntimeGet())
#else
  #define   MkRT_O(o)               MkRT
  #define   MkRT_X(x)               MkRT
  #define   MkRT_ONN(o)             MkRT
  #define   MkRT_ON(o)              MkRT
  #define   MkRT_XN(x)              MkRT
#endif
 
#if META_HAS_THREAD
  #define   MkRtSetup_O(o)            MK_RT_UNUSED MK_RT const mkrt = MkRT_O(o)
  #define   MkRtSetup_X(x)            MK_RT_UNUSED MK_RT const mkrt = MkRT_X(x)
  #define   MkRtSetup_XN(x)           MK_RT_UNUSED MK_RT const mkrt = MkRT_XN(x)
  #define   MkRtSetup_ON(o)           MK_RT_UNUSED MK_RT const mkrt = MkRT_ON(o)
  #define   MkRtSetup_NULL            MK_RT_UNUSED MK_RT const mkrt = MkRuntimeGet()
  #define   MkRtSetup_RT(r)           MK_RT_UNUSED MK_RT const mkrt = r
  #define   MkRtSetupFromRtExt(rtx)   MK_RT_UNUSED MK_RT const mkrt = MkRTEXT_R(rtx).mkrtHead
 
// check "rt" on NULL if available as argument (MK_RT_ARGS).
  #define   MkRtSetup_O_RT(o)         if (mkrt == NULL) mkrt = MkRT_O(o)
  #define   MkRtSetup_ON_RT(o)        if (mkrt == NULL) mkrt = MkRT_ON(o)
  #define   MkRtSetup_X_RT(x)         if (mkrt == NULL) mkrt = MkRT_X(x)
  #define   MkRtSetup_XN_RT(x)        if (mkrt == NULL) mkrt = MkRT_XN(x)
  #define   MkRtSetup_NULL_RT         if (mkrt == NULL) mkrt = MkRuntimeGet()
 
  #define   AllRtSetup_O(o)           MkRtSetup_O(o)
  #define   AllRtSetup_ON(o)          MkRtSetup_ON(o)
  #define   AllRtSetup_X(x)           MkRtSetup_X(x)
  #define   AllRtSetup_XN(x)          MkRtSetup_XN(x)
  #define   AllRtSetup_NULL           MkRtSetup_NULL
#else
  #define   MkRtSetup_O(o)
  #define   MkRtSetup_X(x)
  #define   MkRtSetup_XN(x)
  #define   MkRtSetup_ON(o)
  #define   MkRtSetup_NULL
  #define   MkRtSetup_RT(r)
 
  #define   MkRtSetup_O_RT(o)         
  #define   MkRtSetup_X_RT(x)         
  #define   MkRtSetup_XN_RT(x)        
  #define   MkRtSetup_ON_RT(o)        
  #define   MkRtSetup_NULL_RT
 
  #define   AllRtSetup_O(o)
  #define   AllRtSetup_ON(o)
  #define   AllRtSetup_X(x)
  #define   AllRtSetup_XN(x)
  #define   AllRtSetup_NULL
#endif
 
 
typedef void ( MK_DECL *MkRuntimeInitF) ( MK_RT_ARGS_ONLY );
 
__parser__(ignore)
typedef struct MkRuntimeCallbackS {
  MkRuntimeInitF              cb      ;                                 
 
  #define MkRuntimeCallbackS_ident_size 30
  MK_STRB                     ident[MkRuntimeCallbackS_ident_size+1];   
 
  // private
  bool                        inUse   ;
  size_t                      rtId_plus_1    ;
 
  // CDL list
  struct MkRuntimeCallbackS   *prev   ;
  struct MkRuntimeCallbackS   *next   ;
} MkRuntimeCallbackS;
 
__parser__(ignore)
MK_EXTERN size_t MK_DECL MkRuntimeCallbackAdd ( 
  MK_PARSER_RT
  MkRuntimeCallbackS * cbdata,  
  MkRuntimeInitF       rt_callback,
  MK_STRN              ident
);
 
__parser__(ignore)
MK_EXTERN void MK_DECL MkRuntimeCallbackDel ( MkRuntimeCallbackS * cbdata );
 
// - MkRuntimeCallback
 
__parser__(ignore)
MK_EXTERN_DATA MkThreadLocal struct MkRuntimeS  MkRuntimeRLS ;
 
__parser__(ignore)
MK_EXTERN MK_RT MK_DECL MkRuntimeSetup ( MK_RT const mkrt );
 
__parser__(ignore)
MK_EXTERN void MK_DECL MkRuntimeCleanup ( MK_RT_ARGS_ONLY );
 
MK_ATTR_STATIC __parser__(hide,doc-group=Config)
mk_inline MK_RT MkRuntimeGet ( void )
{
  return __MkCheckX(MkRuntimeC,&MkRuntimeRLS) ? MkRT : MkRuntimeSetup( MkRT );
}
 
MK_ATTR_STATIC __parser__(hide,doc-group=Config)
mk_inline MK_RT MkRuntimeGetFromObj ( 
  MK_OBJ obj  __parser__(null-allowed)
) {
  return MkRT_O(obj);
}
 
// - MkRuntimeC_Interface_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Config);
 
MK_ATTR_STATIC
mk_inline bool MkRuntimeGetIsSilent ( void ) {
  return MkRuntimeRLS.isSilent;
}
 
MK_ATTR_RT_STATIC
mk_inline void MkRuntimeSetIsSilent_RT ( MK_PARSER_RT bool silent );
 
MK_ATTR_STATIC
mk_inline MK_I32 MkRuntimeGetDebug ( void ) {
  return MkRuntimeRLS.debug;
}
 
MK_ATTR_STATIC
mk_inline void MkRuntimeSetDebug ( MK_I32 dbg ) {
  MkRuntimeRLS.debug = dbg;
}
 
MK_ATTR_STATIC
mk_inline MK_STRN MkRuntimeGetLogfile ( void ) {
  return MkSysStringGetNoNULL(MkRuntimeRLS.logfile);
}
 
MK_ATTR_RT_STATIC
MK_EXTERN enum MkErrorE MK_DECL MkRuntimeSetLogfile_RT ( 
  MK_PARSER_RT
  MK_STRN logfile
) ;
 
__parser__(hide)
MK_EXTERN void MK_DECL MkRuntimeSetCID   (MK_OBJ const cid) MK_ATTR_STATIC ;
 
MK_ATTR_RT_STATIC __parser__(error-ignore)
mk_inline enum MkErrorE MkRuntimeGetErrorCode_RT (
  MK_PARSER_RT_ONLY
) {
  MK_STATIC_RT;
  return MkERROR_RT.code;
}
 
__parser__pop__;
 
// - MkRuntimeC_Config_C_API
 
// #######################################################################
// -----------------------------------------------------------------------
 
__parser__push__(doc-group=Info);
 
__parser__(const,class-overload=MkObjectLog)
MK_EXTERN void MK_DECL MkRuntimeLog_RT (
  MK_PARSER_RT
  MK_RTN  const rt        __parser__(default=NULL),
  MK_PARSER_fmtobj        ,
  MK_DBG  const debug     __parser__(default=0),
  MK_STRN const callfunc  __parser__(default=F#FUNC),
  MK_I32  const lvl       __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
__parser__pop__;
 
// - MkRuntimeC_Config_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                   P A C K A G E - A P I                         ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
// #######################################################################
// -----------------------------------------------------------------------
#ifndef MK_EMBEDDED
  #define MK_EMBEDDED(type,call,...) ({ \
    type ret = (type) 0; \
    if (MkErrorCheckI(call (__VA_ARGS__,&ret))) goto error; \
    ret; \
  })
#endif
 
#ifndef MK_EMBEDDED_REF
  #define MK_EMBEDDED_REF(type,call,...) ({ \
    type ret = {0}; \
    if (MkErrorCheckI(call (__VA_ARGS__,&ret))) goto error; \
    ret; \
  })
#endif
 
// MkKernel_Overload_C_API
 
/*****************************************************************************/
/*                                                                           */
/*                            doc functions                                  */
/*                                                                           */
/*****************************************************************************/
 
// -----------------------------------------------------------------------
 
// -----------------------------------------------------------------------
// BEGIN-Class-Doc-Order - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// external
 
// external
 
// internal
 
// external
 
// internal
 
// external
 
// external
 
// internal
 
// external
 
// internal
 
// END-Class-Doc-Order - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                            inline functions                               */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-Class-Introspection - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
__parser__push__(doc-name=Introspection,doc-index=Class,class=MkBufferListC,no-rpc,null-return-allow,flags=new);
 
MK_ATTR_RT_STATIC
mk_inline MK_BFL MkBufferListInstances_RT( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  return (MK_BFL)MkBufferListC_TT->instances;
}
 
MK_ATTR_INSTANCE
mk_inline MK_BFL MkBufferListNext(MK_BFL const bfl) {
  MK_INSTANCE_HDL(bfl);
  return (MK_BFL)MkBufferListC_X2obj(bfl)->obj_protect.next;
}
 
MK_ATTR_INSTANCE
mk_inline MK_BFL MkBufferListPrev(MK_BFL const bfl) {
  MK_INSTANCE_HDL(bfl);
  return (MK_BFL)MkBufferListC_X2obj(bfl)->obj_protect.prev;
}
 
__parser__pop__;
 
// MkBufferListC_Class_C_API
 
 
__parser__push__(doc-name=Introspection,doc-index=Class,class=MkBufferC,no-rpc,null-return-allow,flags=new);
 
MK_ATTR_RT_STATIC
mk_inline MK_BUF MkBufferInstances_RT( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  return (MK_BUF)MkBufferC_TT->instances;
}
 
MK_ATTR_INSTANCE
mk_inline MK_BUF MkBufferNext(MK_BUF const buf) {
  MK_INSTANCE_HDL(buf);
  return (MK_BUF)MkBufferC_X2obj(buf)->obj_protect.next;
}
 
MK_ATTR_INSTANCE
mk_inline MK_BUF MkBufferPrev(MK_BUF const buf) {
  MK_INSTANCE_HDL(buf);
  return (MK_BUF)MkBufferC_X2obj(buf)->obj_protect.prev;
}
 
__parser__pop__;
 
// MkBufferC_Class_C_API
 
 
__parser__push__(doc-name=Introspection,doc-index=Class,class=MkBufferStreamC,no-rpc,null-return-allow,flags=new);
 
MK_ATTR_RT_STATIC
mk_inline MK_BUS MkBufferStreamInstances_RT( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  return (MK_BUS)MkBufferStreamC_TT->instances;
}
 
MK_ATTR_INSTANCE
mk_inline MK_BUS MkBufferStreamNext(MK_BUS const bus) {
  MK_INSTANCE_HDL(bus);
  return (MK_BUS)MkBufferStreamC_X2obj(bus)->obj_protect.next;
}
 
MK_ATTR_INSTANCE
mk_inline MK_BUS MkBufferStreamPrev(MK_BUS const bus) {
  MK_INSTANCE_HDL(bus);
  return (MK_BUS)MkBufferStreamC_X2obj(bus)->obj_protect.prev;
}
 
__parser__pop__;
 
// MkBufferStreamC_Class_C_API
 
 
__parser__push__(doc-name=Introspection,doc-index=Class,class=MkErrorC,no-rpc,null-return-allow,flags=new);
 
MK_ATTR_RT_STATIC
mk_inline MK_ERR MkErrorInstances_RT( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  return (MK_ERR)MkErrorC_TT->instances;
}
 
MK_ATTR_INSTANCE
mk_inline MK_ERR MkErrorNext(MK_ERR const err) {
  MK_INSTANCE_HDL(err);
  return (MK_ERR)MkErrorC_X2obj(err)->obj_protect.next;
}
 
MK_ATTR_INSTANCE
mk_inline MK_ERR MkErrorPrev(MK_ERR const err) {
  MK_INSTANCE_HDL(err);
  return (MK_ERR)MkErrorC_X2obj(err)->obj_protect.prev;
}
 
__parser__pop__;
 
// MkErrorC_Class_C_API
 
 
__parser__push__(doc-name=Introspection,doc-index=Class,class=MkLogFileC,no-rpc,null-return-allow,flags=new);
 
MK_ATTR_RT_STATIC
mk_inline MK_LFL MkLogFileInstances_RT( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  return (MK_LFL)MkLogFileC_TT->instances;
}
 
MK_ATTR_INSTANCE
mk_inline MK_LFL MkLogFileNext(MK_LFL const lfl) {
  MK_INSTANCE_HDL(lfl);
  return (MK_LFL)MkLogFileC_X2obj(lfl)->obj_protect.next;
}
 
MK_ATTR_INSTANCE
mk_inline MK_LFL MkLogFilePrev(MK_LFL const lfl) {
  MK_INSTANCE_HDL(lfl);
  return (MK_LFL)MkLogFileC_X2obj(lfl)->obj_protect.prev;
}
 
__parser__pop__;
 
// MkLogFileC_Class_C_API
 
 
__parser__push__(doc-name=Introspection,doc-index=Class,class=MkObjectC,no-rpc,null-return-allow);
 
MK_ATTR_RT_STATIC
mk_inline MK_OBJ MkObjectInstances_RT( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  return (MK_OBJ)MkObjectC_TT->instances;
}
 
MK_ATTR_INSTANCE
mk_inline MK_OBJ MkObjectNext(MK_OBJ const obj) {
  MK_INSTANCE_HDL(obj);
  return (MK_OBJ)MkObjectC_X2obj(obj)->obj_protect.next;
}
 
MK_ATTR_INSTANCE
mk_inline MK_OBJ MkObjectPrev(MK_OBJ const obj) {
  MK_INSTANCE_HDL(obj);
  return (MK_OBJ)MkObjectC_X2obj(obj)->obj_protect.prev;
}
 
__parser__pop__;
 
// MkObjectC_Class_C_API
 
 
__parser__push__(doc-name=Introspection,doc-index=Class,class=MkRuntimeC,no-rpc,null-return-allow,flags=new);
 
MK_ATTR_RT_STATIC
mk_inline MK_RT MkRuntimeInstances_RT( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  return (MK_RT)MkRuntimeC_TT->instances;
}
 
MK_ATTR_INSTANCE
mk_inline MK_RT MkRuntimeNext(MK_RT const rt) {
  MK_INSTANCE_HDL(rt);
  return (MK_RT)MkRuntimeC_X2obj(rt)->obj_protect.next;
}
 
MK_ATTR_INSTANCE
mk_inline MK_RT MkRuntimePrev(MK_RT const rt) {
  MK_INSTANCE_HDL(rt);
  return (MK_RT)MkRuntimeC_X2obj(rt)->obj_protect.prev;
}
 
__parser__pop__;
 
// MkRuntimeC_Class_C_API
 
// END-Class-Introspection - created by 'c_Class.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
__parser__global__(MkRuntimeInstances:hide);
__parser__global__(MkRuntimeNext:hide);
__parser__global__(MkRuntimePrev:hide);
 
MK_ATTR_RT_STATIC
__parser__(internal)
mk_inline MK_OBJ MkObjectInstancesOfType_RT( MK_PARSER_RT MK_SIG typeSIG ) {
  // TODO replace loop by hash
  MkTypeLoop(MkTypeC,typ) {
    if ((*typ).objsig == typeSIG) return (*typ).instances;
  }
  return NULL;
}
 
/*
mk_inline MK_SIG MkObjectRpcHdlGet(MK_OBJ obj) {
  return (*obj).rpcHdl;
}
*/
 
// =============================================================================================================
 
MK_ATTR_RT_STATIC
mk_inline MK_ERR MkErrorPANIC_RT ( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  MkERROR.format_of_error = MK_ERROR_PANIC;
  return &MkERROR;
}
 
MK_ATTR_RT_STATIC
mk_inline MK_ERR MkErrorIGNORE_RT ( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  MkERROR.format_of_error = MK_ERROR_IGNORE;
  return &MkERROR;
}
 
MK_ATTR_RT_STATIC
mk_inline MK_ERR MkErrorPRINT_RT ( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  MkERROR.format_of_error = MK_ERROR_PRINT;
  return &MkERROR;
}
 
MK_ATTR_RT_STATIC
mk_inline MK_ERR MkErrorDEFAULT_RT ( MK_PARSER_RT_ONLY ) {
  MK_STATIC_RT;
  MkERROR.format_of_error = MK_ERROR_DEFAULT;
  return &MkERROR;
}
 
mk_inline enum MkErrorE
MkSelfNew_RT (
  MK_PARSER_RT
  MK_OBJ  obj,
  MK_PTR  *self_out,
  MK_PTR  const env
) {
  assert(self_out != NULL);
 
  if (obj == NULL) {
    *self_out = NULL;
    return MK_OK;
  }
  MkRtSetup_ON_RT(obj);
 
  enum MkErrorE ret = MK_OK;
  MK_PTR self = MkSelfGet(obj);
  if (self != NULL) {
    if (MkRefGet(obj) <= 0) {
      MkErrorSetV_2M(obj, "RefCount Error: object '%s' has 'self' but 'refCout <= 0", obj->type->type_name);
      goto error;
    } else {
      ret = MK_CONTINUE;
      if (MK_RT_REF.MkSelfIncrOnCacheB && MK_RT_REF.fSelfIncr) (*MK_RT_REF.fSelfIncr)(MK_RT_CALL self, env);
      goto end;
    }
  }
  self = MkSelfCreate(obj, env);
  if (self == NULL) {
    MkErrorSetV_2M(obj, "Error: '%s->SelfCreate' return a NULL pointer", obj->type->type_name);
    goto error;
  }
end:
  *self_out = self;
  return ret;
error:
  *self_out = NULL;
  return MK_ERROR;
}
 
 
MK_ATTR_RT_INSTANCE mk_inline MK_ERR MkObjectToError_RT ( 
  MK_PARSER_RT
  MK_OBJ const obj 
) {
  MK_INSTANCE_RT_O(obj);
  return MkErrorFORMAT_1O(obj);
}
 
#define MkObjectToError_1X(obj) MkObjectToError(MkOBJ(obj))
 
// MkObjectC_Misc_C_API
 
 
MK_ATTR_RT_STATIC
mk_inline MkBinaryR MkBinaryDup_RT ( MK_PARSER_RT const MkBinaryR bin ) {
  MK_STATIC_RT;
  return MkBinaryCreate(bin.size,(MK_BIN)MkSysMemDup(MK_ERROR_PANIC,bin.data,(size_t)bin.size));
}
 
MK_ATTR_RT_STATIC
mk_inline void MkBinaryLog_RT ( MK_PARSER_RT const MkBinaryR bin ) {
  MK_STATIC_RT;
  MkLogV(MK_ERROR_FORMAT,__func__,0,"MkBinaryR: size=%li, data=%p\n", bin.size, bin.data);
}
 
 
 
MK_ATTR_RT_STATIC
mk_inline MkStringR MkStringDup_RT ( MK_PARSER_RT MkStringR const str ) {
  MK_STATIC_RT;
  return MkStringCreate(str.len,(MK_STRN)MkSysMemDup(MK_ERROR_PANIC,str.ptr,(size_t)str.len));
}
 
MK_ATTR_RT_STATIC
mk_inline void MkStringLog_RT ( MK_PARSER_RT MkStringR const str, MK_STRN func ) {
  MK_STATIC_RT;
  MkLogV(MK_ERROR_FORMAT,func,0,"MkStringR: len=%i -> %.*s\n", str.len, str.len, str.ptr);
}
 
 
MK_ATTR_RT_STATIC
mk_inline void MkRuntimeSetIsSilent_RT ( MK_PARSER_RT bool silent ) {
  MK_STATIC_RT;
  MkLogC(MK_ERROR_FORMAT, "Attention: set 'silient'\n", 1, __func__);
  MkSysPrintTrace(MK_ERROR_FORMAT,0,-1,1,__func__,0);
  MkRuntimeRLS.isSilent = silent;
};
 
// end c++ save definition
END_MK_C_DECLS
// END: BEGIN_MK_C_DECLS
 
#endif // KERNEL_MK_H
 
// vim:nowrap