LibMkKernel_rb.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#include "LibMkKernel_private_rb.h"
#include "misc_check_rb.h"
 
/* LABEL-END */
 
#include <ruby/defines.h>
 
VALUE MK(MkKernel)  = 0;
VALUE MK(globalRef) = 0;
VALUE MK(cEnum)     = 0;
VALUE MK(InitError) = 0;
VALUE MK(NULL_STR)  = 0;
 
ID NS(id_caller);
ID NS(id_caller_locations);
ID NS(id_label);
ID NS(id_path);
ID NS(id_bn);
ID NS(id_lineno);
 
ID NS(id_arity);
ID NS(id_clone);
ID NS(id_unbind);
ID NS(id_bind);
ID NS(id_receiver);
ID NS(id_enum_attr);
ID NS(id_to_i);
ID NS(id_full_message);
 
// BEGIN-enumD - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
VALUE MK(MkErrorE);
VALUE MK(MkIdSE);
VALUE MK(MkTimeoutE);
VALUE MK(MkTypeE);
 
// END-enumD - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define MkSetupTmpl() MkSetup()
#define MkCleanupTmpl()
 
// #######################################################################
// -----------------------------------------------------------------------
// documentation order
 
 
 
 
 
 
 
 
 
 
 
// BEGIN-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkKernel,EnumFunc,sco,func
#define ErrorE_FromInt_doc "MkErrorE MkKernel.ErrorE_FromInt(value:int32)"
#define IdSE_FromInt_doc "MkIdSE MkKernel.IdSE_FromInt(value:int32)"
#define TimeoutE_FromInt_doc "MkTimeoutE MkKernel.TimeoutE_FromInt(value:int32)"
#define TypeE_FromInt_doc "MkTypeE MkKernel.TypeE_FromInt(value:int32)"
 
// doc-key: MkKernel,EnumFunc,sm_,func
#define ErrorE_ToInt_doc "int32 MkKernel.ErrorE_ToInt(value:MkErrorE)"
#define ErrorE_ToString_doc "string MkKernel.ErrorE_ToString(value:MkErrorE)"
#define IdSE_ToInt_doc "int32 MkKernel.IdSE_ToInt(value:MkIdSE)"
#define IdSE_ToString_doc "string MkKernel.IdSE_ToString(value:MkIdSE)"
#define TimeoutE_ToInt_doc "int32 MkKernel.TimeoutE_ToInt(value:MkTimeoutE)"
#define TimeoutE_ToString_doc "string MkKernel.TimeoutE_ToString(value:MkTimeoutE)"
#define TypeE_ToInt_doc "int32 MkKernel.TypeE_ToInt(value:MkTypeE)"
#define TypeE_ToString_doc "string MkKernel.TypeE_ToString(value:MkTypeE)"
 
// doc-key: MkKernel,Setup,sm_,func
#define Cleanup_doc "MkKernel.Cleanup()"
#define Setup_doc "MkKernel.Setup()"
 
// END-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
#define OT_SETUP_hdl_static   MK_RT_UNUSED MkRtSetup_NULL; \
                              __attribute__((unused)) MK_ERR hdl = &MkERROR;
 
/*****************************************************************************/
/*                                                                           */
/*                        calling proc information                           */
/*                                                                           */
/*****************************************************************************/
 
void NS(_printObj) (MK_RT_ARGS VALUE v, MK_STRN caller) {
  MkLogV_4M(MK_ERROR_PRINT,caller,0, "printObj: value<%p> class<%s> %s\n", \
                                                  (void*) v, OT_LNG_OBJ_CLASSNAME(v), VAL2STRN(rb_inspect(v)));
}
 
void NS(printLNG_STACK)(MK_RT_ARGS MK_MNG mng) {
  VALUE arg;
  VALUE ary = rb_funcall(rb_mKernel, NS(id_caller), 0,0);
  while ((arg = rb_ary_shift(ary)) != Qnil) {
    printXC2(mng, VAL2STRN(arg));
  }
}
 
#define FRAME_init                                                                                \
  VALUE frame = 0;                                                                                \
  if (frameP == NULL || *frameP == 0) {                                                           \
    VALUE ary = rb_funcall(rb_mKernel, NS(id_caller_locations), 2, INT2FIX(skip), INT2FIX(1));    \
    frame = rb_ary_entry(ary,0);                                                                  \
    if (frameP != NULL) *frameP = frame;                                                          \
  } else {                                                                                        \
    frame = *frameP;                                                                              \
  }                                                                                               \
 
MK_STRN NS(Get_Call_Proc) (int skip, VALUE* frameP) {
  FRAME_init
  VALUE label = rb_funcallv(frame, NS(id_label), 0, NULL);
  return VAL2STRN(label);
}
 
MK_STRN NS(Get_Call_Script) (int skip, VALUE* frameP) {
  FRAME_init
  VALUE path = rb_funcallv(frame, NS(id_path), 0, NULL);
  VALUE base = rb_funcall(rb_cFile, NS(id_bn), 1, path);
  return VAL2STRN(base);
}
 
MK_I32 NS(Get_Call_Line) (int skip, VALUE* frameP) {
  FRAME_init
  VALUE line = rb_funcallv(frame, NS(id_lineno), 0, NULL);
  return VAL2I32(line);
}
 
void NS(Get_Call_All) (int skip, MK_STRN *proc, MK_STRN *file, MK_I32 *line) {
  VALUE ary = rb_funcall(rb_mKernel, NS(id_caller_locations), 2, INT2FIX(skip), INT2FIX(1));
  VALUE a0 = rb_ary_entry(ary,0);
  if (proc) {
    *proc = VAL2STRN(rb_funcallv(a0, NS(id_label), 0, NULL));
  }
  if (file) {
    VALUE path = rb_funcall(a0, NS(id_path), 0);
    *file = VAL2STRN(rb_funcall(rb_cFile, NS(id_bn), 1, path));
  }
  if (line) {
    *line = VAL2I32(rb_funcallv(a0, NS(id_lineno), 0, NULL));
  }
}
 
void NS(Get_Call_Stack) (MK_RT_ARGS MK_ERR const err, int level) {
  VALUE ary = rb_funcall(rb_mKernel, NS(id_caller_locations), 2, INT2FIX(level), INT2FIX(1));
  VALUE a0 = rb_ary_entry(ary,0);
  VALUE path = rb_funcallv(a0, NS(id_path), 0, NULL);
 
  MkErrorStackFormat(err,
    VAL2STRN(rb_funcallv(a0, NS(id_label), 0, NULL)),
      VAL2STRN(rb_funcall(rb_cFile, NS(id_bn), 1, path)),
        VAL2I32(rb_funcallv(a0, NS(id_lineno), 0, NULL))
  );
}
 
/*****************************************************************************/
/*                                                                           */
/*                             Obj_As                                        */
/*                                                                           */
/*****************************************************************************/
 
#include "tmpl/mk_misc_ObjAs_lng.h"
 
enum MkErrorE NS(Obj_AsSTRN) (OT_Check_ARGS, MK_STRN *retP) {
  if ((*skipP) >= objc) {
    return WrongNumArgs(hdl,(*skipP), objc, -999, +999, arg);
  }
  VALUE obj   = objv[(*skipP)++];
  VALUE strO  = rb_obj_as_string(obj);
  long  len   = RSTRING_LEN(strO);
  MK_STRN ret = RSTRING_PTR(strO);
  // mark=MK_NULL
  if (MK_NULL_STR_CHECK(ret,len)) {
    ret = NULL;
  }
  *retP = ret;
  return MK_OK;
}
 
enum MkErrorE NS(Obj_AsSTR_COPY) (OT_Check_ARGS, MK_STR ret, size_t size) {
  if ((*skipP) >= objc) {
    return WrongNumArgs(hdl,(*skipP), objc, -999, +999, arg);
  }
  VALUE obj = objv[(*skipP)++];
  strncpy(ret,VAL2STRN(obj),size);
  return MK_OK;
}
 
/*****************************************************************************/
/*                                                                           */
/*                              check                                        */
/*                                                                           */
/*****************************************************************************/
 
static enum MkErrorE MK(LngListToMkBufferListS) ( 
  OT_Prefix_ARGS 
  VALUE argsO, 
  MK_BFL *argsP 
) {
  MK_BFL args = *argsP;
  //MK_BFL orig = args;
  if (!OT_LNG_ARRAY_IS(argsO)) {
    return MK_OK;
  } else {
    *argsP = NULL;
    long len = rb_array_len(argsO);
    if (args == NULL) args = MkBufferListCreate (rb_long2int(len));
    for (long i=0; i<len; i++) {
      MkBufferListAppendSTR(args, VAL2STRN(rb_ary_entry(argsO,i)));
    }
  }
  *argsP = args;
  return MK_OK;
}
 
enum MkErrorE MK(LngTupleToMkBufferListS) (
  SETUP_ARGS,
  int     *origskip,
  MK_BFL  *argsP
) {
  MK_BFL args = *argsP;
  int skip = origskip==NULL ? 0 : *origskip;
  if (objv == NULL) {
    return MK_OK;
  } else {
    *argsP = NULL;
    if (args == NULL) args = MkBufferListCreate (objc-skip);
    for (; skip < objc; skip++) {
      MkBufferListAppendSTR(args, VAL2STRN(objv[skip]));
    }
  }
  *origskip = skip;
  *argsP = args;
  return MK_OK;
}
 
#include "tmpl/mk_misc_check_lng.h"
 
/*****************************************************************************/
/*                                                                           */
/*                                private                                    */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-MkKernel - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkKernel,MkKernel-Enum,sco
 
static OT_ProcRet NS(MkKernel_ErrorE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkErrorE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkErrorE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,value_out));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_IdSE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdSE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkIdSE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkIdSE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(IdSE,value_out));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TimeoutE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TimeoutE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkTimeoutE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkTimeoutE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TimeoutE,value_out));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TypeE_FromInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TypeE_FromInt_doc);
  MK_I32 value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (value))
  OT_CHECK_NOARGS;
  enum MkTypeE value_out;
  MkErrorC_Check(MK_ERROR_FORMAT,MkTypeE_FromInt (value, &value_out));
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TypeE,value_out));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// doc-key: MkKernel,MkKernel-Enum,sm_
 
static OT_ProcRet NS(MkKernel_ErrorE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToInt_doc);
  enum MkErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkErrorE_ToInt (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_ErrorE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(ErrorE_ToString_doc);
  enum MkErrorE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkErrorE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkErrorE_ToString (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_IdSE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdSE_ToInt_doc);
  enum MkIdSE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkIdSE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkIdSE_ToInt (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_IdSE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IdSE_ToString_doc);
  enum MkIdSE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkIdSE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkIdSE_ToString (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TimeoutE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TimeoutE_ToInt_doc);
  enum MkTimeoutE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTimeoutE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkTimeoutE_ToInt (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TimeoutE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TimeoutE_ToString_doc);
  enum MkTimeoutE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTimeoutE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkTimeoutE_ToString (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TypeE_ToInt) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TypeE_ToInt_doc);
  enum MkTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkTypeE_ToInt (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_TypeE_ToString) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(TypeE_ToString_doc);
  enum MkTypeE value = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTypeE,value))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkTypeE_ToString (value));
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkKernel_Enum_RB_API
 
 
// doc-key: MkKernel,MkKernel-Setup-libmkkernel,sm_
 
static OT_ProcRet NS(MkKernel_Cleanup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Cleanup_doc);
  OT_CHECK_NOARGS;
  MkCleanupTmpl ();
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkKernel_Setup) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Setup_doc);
  OT_CHECK_NOARGS;
  MkSetupTmpl ();
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}
 
// MkKernel_Setup_libmkkernel_RB_API
 
// END-MkKernel - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// **************************************************************************
 
static OT_ProcRet MK(RubyMsgque_M) (OtClass_ARGS) {
  OT_SETUP_hdl_static
  OT_SETUP_VARARGS(1,1,"M(repeat*10)")
  VALUE strO = 0;
  OT_CHECK_REQUIRED(OT_CHECK_LNG_T (strO))
  OT_CHECK_NOARGS
  OT_retObj_SET_None
  OT_GET_CALL_ALL
  strO = rb_funcall(rb_obj_as_string(strO), rb_intern("*"), 1, INT2VAL(17));
  MkLogV_4M(MK_ERROR_PRINT,proc,0, "%s [%s:%d]\n", VAL2STRN(strO), file, line);
  OT_retObj_RETURN
}
 
static OT_ProcRet MK(RubyMsgque_printObj) (OtClass_ARGS) {
  OT_SETUP_hdl_static
  OT_SETUP_VARARGS(1,2,"printObj object ?caller?")
  VALUE obj = 0;
  OT_CHECK_REQUIRED(OT_CHECK_LNG_T (obj))
  MK_STRN caller = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (caller))
  OT_CHECK_NOARGS
  OT_retObj_SET_None
  if (caller == NULL) caller = OT_GET_CALL_PROC;
  MK(_printObj)(MK_RT_CALL obj,caller);
  OT_retObj_RETURN
}
 
/*****************************************************************************/
/*                                                                           */
/*                                public                                     */
/*                                                                           */
/*****************************************************************************/
 
void MK(MkKernel_Init) (MK_RT_ARGS_ONLY) {
  MK(MkKernel) = rb_define_module("MkKernel");
 
  OT_METH_S ( MkKernel, M,                         RubyMsgque_M                         )
  OT_METH_O ( MkKernel, M,                         RubyMsgque_M                         )
 
  OT_METH_S ( MkKernel, printObj,                  RubyMsgque_printObj                  )
  OT_METH_O ( MkKernel, printObj,                  RubyMsgque_printObj                  )
 
// BEGIN-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkKernel,EnumFunc,sco
OT_METH_O ( MkKernel, ErrorE_FromInt,            MkKernel_ErrorE_FromInt             )
OT_METH_S ( MkKernel, ErrorE_FromInt,            MkKernel_ErrorE_FromInt             )
OT_METH_O ( MkKernel, IdSE_FromInt,              MkKernel_IdSE_FromInt               )
OT_METH_S ( MkKernel, IdSE_FromInt,              MkKernel_IdSE_FromInt               )
OT_METH_O ( MkKernel, TimeoutE_FromInt,          MkKernel_TimeoutE_FromInt           )
OT_METH_S ( MkKernel, TimeoutE_FromInt,          MkKernel_TimeoutE_FromInt           )
OT_METH_O ( MkKernel, TypeE_FromInt,             MkKernel_TypeE_FromInt              )
OT_METH_S ( MkKernel, TypeE_FromInt,             MkKernel_TypeE_FromInt              )
 
// doc-key: MkKernel,EnumFunc,sm_
OT_METH_O ( MkKernel, ErrorE_ToInt,              MkKernel_ErrorE_ToInt               )
OT_METH_S ( MkKernel, ErrorE_ToInt,              MkKernel_ErrorE_ToInt               )
OT_METH_O ( MkKernel, ErrorE_ToString,           MkKernel_ErrorE_ToString            )
OT_METH_S ( MkKernel, ErrorE_ToString,           MkKernel_ErrorE_ToString            )
OT_METH_O ( MkKernel, IdSE_ToInt,                MkKernel_IdSE_ToInt                 )
OT_METH_S ( MkKernel, IdSE_ToInt,                MkKernel_IdSE_ToInt                 )
OT_METH_O ( MkKernel, IdSE_ToString,             MkKernel_IdSE_ToString              )
OT_METH_S ( MkKernel, IdSE_ToString,             MkKernel_IdSE_ToString              )
OT_METH_O ( MkKernel, TimeoutE_ToInt,            MkKernel_TimeoutE_ToInt             )
OT_METH_S ( MkKernel, TimeoutE_ToInt,            MkKernel_TimeoutE_ToInt             )
OT_METH_O ( MkKernel, TimeoutE_ToString,         MkKernel_TimeoutE_ToString          )
OT_METH_S ( MkKernel, TimeoutE_ToString,         MkKernel_TimeoutE_ToString          )
OT_METH_O ( MkKernel, TypeE_ToInt,               MkKernel_TypeE_ToInt                )
OT_METH_S ( MkKernel, TypeE_ToInt,               MkKernel_TypeE_ToInt                )
OT_METH_O ( MkKernel, TypeE_ToString,            MkKernel_TypeE_ToString             )
OT_METH_S ( MkKernel, TypeE_ToString,            MkKernel_TypeE_ToString             )
 
// doc-key: MkKernel,Setup,sm_
OT_METH_O ( MkKernel, Cleanup,                   MkKernel_Cleanup                    )
OT_METH_S ( MkKernel, Cleanup,                   MkKernel_Cleanup                    )
OT_METH_O ( MkKernel, Setup,                     MkKernel_Setup                      )
OT_METH_S ( MkKernel, Setup,                     MkKernel_Setup                      )
 
// END-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// BEGIN-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// → no data
 
// END-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
}
 
/*****************************************************************************/
/*                                                                           */
/*                                 sys                                       */
/*                                                                           */
/*****************************************************************************/
 
/*
static rb_pid_t SysFork (
)
{
  rb_pid_t pid = rb_fork(0, 0, 0, Qnil);
  if (pid == 0) rb_thread_atfork();
  return pid;
}
 
static enum MkErrorE SysServerSpawn (
  struct MkS * const mqctx,
  char * * argv,
  MK_STRN  name,
  struct MkIdS * idP
)
{
  rb_pid_t pid;
  VALUE args = rb_ary_new();
  MK_BUF tmp = mqctx->temp;
 
  MkBufferReset(tmp);
 
  // spawn setup !before! a spawn is created
  if (mqctx->setup.fSpawnInit) (*mqctx->setup.fSpawnInit)(mqctx);
 
  // fill the args
  for (;*argv!=NULL; argv++) {
printC(*argv)
    rb_ary_push(args, STRN2VAL(*argv));
  }
 
  // use ruby spawn
  pid = rb_spawn_err(RARRAY_LEN(args), RARRAY_PTR(args), tmp->cur.C, tmp->size);
 
  // check for error
  if (pid == -1) {
    return MkErrorSetC (tmp->cur.C, mqctx, name, 1);
  }
 
  // return ok
  (*idP).val = pid;
  (*idP).type = MK_ID_PROCESS;
  return MK_OK;
}
*/
 
/*
static VALUE
sSysServerThreadInit(MK_PTR data)
{
  MkSysServerThreadMain((struct MkSysServerThreadMainS*)data);
  //return rb_last_status_get();
  return Qnil;
}
 
static VALUE SysServerThread2 (VALUE data) {
  VALUE ret = rb_thread_create(sSysServerThreadInit, VAL2PTR(data));
  // make thread_id persistent
  INCR_REG(ret);
  return ret;
}
 
static enum MkErrorE SysServerThread (
  struct MkS * const mqctx,
  struct MkFactoryS factory,
  struct MkBufferListS ** argvP,
  struct MkBufferListS ** alfaP,
  MK_STRN  name,
  int state,
  struct MkIdS * idP
)
{
  VALUE ret;
 
  // fill thread data
  struct MkSysServerThreadMainS * argP = (struct MkSysServerThreadMainS *) MkSysMalloc(MK_ERROR_PANIC,sizeof(*argP));
  argP->factory = factory;
  argP->argv = *argvP;
  argP->alfa = *alfaP;
  argP->tmpl = mqctx;
 
  // pointers are now owned by SysServerThread
  *argvP = NULL;
  *alfaP = NULL;
 
  // after a "thread" no "fork" is possible
  MkConfigSetIgnoreFork (mqctx, MK_YES);
 
  // start thread
  NIL_Check(ret = rb_protect(SysServerThread2, PTR2VAL(argP), NULL));
 
  // save tid
  (*idP).val = ret;
  (*idP).type = MK_ID_THREAD;
 
  return MK_OK;
 
error:
  MkBufferListDelete (&argP->argv);
  MkBufferListDelete (&argP->alfa);
  MkSysFree (argP);
  return MK_ERROR;
}
*/
 
// PROBLEM: After RUBY 'rb_exit' the code is NOT stoped, insted an Exit-Exception is raised
//          and code jump to the next 'rescue' etc.
// This create a lot of problems in a server on recursion:
//  1. after 'MqExit→rb_exit' the 'context' is deleted but likely used in 'rescue'.
//      Result: A "'MqContextC' hdl is NULL (RuntimeError)" is raised
//  2. after FORK→MqExit→rb_Exit the code continue to work with code from the
//      !! FORK-CLIENT  !!, still available on the FORK-server. (everything is forked...)
//      Result: unpredictable, perhaps unbalanced RefCountProtection with MK_RT_REF.cid etc
//  3. etc... 
 
#define USE_SysExit
 
#ifdef USE_SysExit
 
static VALUE MK(SysExit2)(VALUE dummy) {
  VALUE thread = rb_thread_current();
  DECR_REG(thread);
  rb_thread_kill(thread);
  return Qnil;
}
static int MK(SysExit) (
  MK_RT_ARGS
  int isThread,
  int num
) {
  if (isThread) {
    rb_protect(MK(SysExit2),Qnil,NULL);
  } else {
    if (MkRefCidN_NULL() == 0) {
      // 0 = toplevel
      rb_exit(num);
    }
  }
  exit(num);
  return num;
}
#endif
 
/*****************************************************************************/
/*                                                                           */
/*                                 init                                      */
/*                                                                           */
/*****************************************************************************/
 
MK_RB_EXTERN void LibMkKernel() 
{
 
  // Register system
#ifdef HAVE_FORK
//  MkInitSysAPI(MK(fork),NULL);
#endif
 
  // Initialize libmkkernel
  MkSetup();
  MkRtSetup_NULL;
 
  // Initialize components
 
  MK(globalRef)            = rb_ary_new();
  rb_gc_register_mark_object(MK(globalRef));
 
  MK(MkKernel_Init)         (MK_RT_CALL_ONLY)  ;
  MK(MkObjectC_Init)        (MK_RT_CALL_ONLY)  ;
  MK(MkBufferC_Init)        (MK_RT_CALL_ONLY)  ;
  MK(MkBufferStreamC_Init)  (MK_RT_CALL_ONLY)  ;
  MK(MkBufferListC_Init)    (MK_RT_CALL_ONLY)  ;
  MK(MkLogFileC_Init)       (MK_RT_CALL_ONLY)  ;
  MK(MkErrorC_Init)         (MK_RT_CALL_ONLY)  ;
  MK(MkExceptionC_Init)     (MK_RT_CALL_ONLY)  ;
  MK(MkRuntimeC_Init)       (MK_RT_CALL_ONLY)  ;
 
 
  // set global data
  
  // Get_Call_???
  NS(id_caller)            =  rb_intern("caller") ;
  NS(id_caller_locations)  =  rb_intern("caller_locations") ;
  NS(id_label)             =  rb_intern("label") ;
  NS(id_path)              =  rb_intern("path") ;
  NS(id_bn)                =  rb_intern("basename") ;
  NS(id_lineno)            =  rb_intern("lineno") ;
 
  // update LAL
  //MkLal.SysFork         = (MkSysForkF)    SysFork       ;
 
  //MkLal.SysServerThread = SysServerThread;
#ifdef USE_SysExit
  MkLal.MkSysExitCB       = MK(SysExit);
#endif
  //MkLal.SysWait         = SysWait;
 
  //MkLal.SysSelect       = (MkSysSelectF) rb_thread_select;
  //MkLal.SysSelect       = (MkSysSelectF) rb_thread_fd_select;
 
  /*****************************************************************************/
  /*                                                                           */
  /*                                enums                                      */
  /*                                                                           */
  /*****************************************************************************/
 
  NS(cEnum) = rb_eval_string(
    "                                                 \n\
      class Enum                                      \n\
                                                      \n\
        private                                       \n\
                                                      \n\
        def self.enum_attr(name, num)                 \n\
          name = name.to_s                            \n\
                                                      \n\
          define_method(name + '?') do                \n\
            @attrs & num != 0                         \n\
          end                                         \n\
                                                      \n\
          define_method(name + '=') do |set|          \n\
            if set                                    \n\
              @attrs |= num                           \n\
            else                                      \n\
              @attrs &= ~num                          \n\
            end                                       \n\
          end                                         \n\
                                                      \n\
          self.const_set(name,self.new(num))          \n\
        end                                           \n\
                                                      \n\
        public                                        \n\
                                                      \n\
        def initialize(attrs = 0)                     \n\
          @attrs = attrs                              \n\
        end                                           \n\
                                                      \n\
        def to_i                                      \n\
          @attrs                                      \n\
        end                                           \n\
                                                      \n\
        alias_method :to_int, :to_i                   \n\
                                                      \n\
      end                                             \n\
      Enum                                            \n\
    "
  );
 
  MK(InitError) = rb_define_class_under(MK(MkKernel), "InitError", rb_eStandardError);
 
  NS(id_enum_attr) = rb_intern("enum_attr");
 
  // BEGIN-enumF - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  MK(MkErrorE) = rb_define_class_under(MK(MkKernel), "MkErrorE", MK(cEnum));
  rb_funcall(MK(MkErrorE), MK(id_enum_attr), 2, STRN2VAL("OK"),         INT2NUM(0));
  rb_funcall(MK(MkErrorE), MK(id_enum_attr), 2, STRN2VAL("CONTINUE"),   INT2NUM(1));
  rb_funcall(MK(MkErrorE), MK(id_enum_attr), 2, STRN2VAL("ERROR"),      INT2NUM(2));
 
  MK(MkIdSE) = rb_define_class_under(MK(MkKernel), "MkIdSE", MK(cEnum));
  rb_funcall(MK(MkIdSE), MK(id_enum_attr), 2, STRN2VAL("UNUSED"),     INT2NUM(0));
  rb_funcall(MK(MkIdSE), MK(id_enum_attr), 2, STRN2VAL("PROCESS"),    INT2NUM(1));
  rb_funcall(MK(MkIdSE), MK(id_enum_attr), 2, STRN2VAL("THREAD"),     INT2NUM(2));
 
  MK(MkTimeoutE) = rb_define_class_under(MK(MkKernel), "MkTimeoutE", MK(cEnum));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("INIT"),       INT2NUM(900));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("LONG"),       INT2NUM(( 900/5 )));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("NORMAL"),     INT2NUM(( 900/10 < 1 ? 1 : 900/10 )));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("SHORT"),      INT2NUM(( 900/45 < 1 ? 1 : 900/45 )));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("SOCKET"),     INT2NUM(( 900/90 < 1 ? 1 : 900/90 )));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("VERYSHORT"),  INT2NUM(( 900/180 < 1 ? 1 : 900/180 )));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("DEFAULT"),    INT2NUM(-1));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("USER"),       INT2NUM(-2));
  rb_funcall(MK(MkTimeoutE), MK(id_enum_attr), 2, STRN2VAL("MAX"),        INT2NUM(-3));
 
  MK(MkTypeE) = rb_define_class_under(MK(MkKernel), "MkTypeE", MK(cEnum));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("I8T"),        INT2NUM(( ( 1 << 4 ) | ( 1<<0 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("BOLT"),       INT2NUM(( ( 2 << 4 ) | ( 1<<0 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("I16T"),       INT2NUM(( ( 3 << 4 ) | ( 1<<1 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("I32T"),       INT2NUM(( ( 4 << 4 ) | ( 1<<2 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("FLTT"),       INT2NUM(( ( 5 << 4 ) | ( 1<<2 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("I64T"),       INT2NUM(( ( 6 << 4 ) | ( 1<<3 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("DBLT"),       INT2NUM(( ( 7 << 4 ) | ( 1<<3 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("BINT"),       INT2NUM(( ( 8 << 4 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("STRT"),       INT2NUM(( ( 9 << 4 ) )));
  rb_funcall(MK(MkTypeE), MK(id_enum_attr), 2, STRN2VAL("LSTT"),       INT2NUM(( ( 10 << 4 ) )));
 
  // END-enumF - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  NS(id_arity)        = rb_intern("arity");
  NS(id_clone)        = rb_intern("clone");
  NS(id_unbind)       = rb_intern("unbind");
  NS(id_bind)         = rb_intern("bind");
  NS(id_receiver)     = rb_intern("receiver");
  NS(id_to_i)         = rb_intern("to_i");
  NS(id_full_message) = rb_intern("full_message");
 
  MK(NULL_STR)        = rb_str_new_cstr(MK_NULL_STR);
  INCR_REG(MK(NULL_STR));
}