MkRuntimeC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "MkRuntimeC_py.c"
 
#include "LibMkKernel_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(MkRuntimeCR))
#define OT_CLASS_NAME               "MkRuntimeC"
 
#define OT_LNG2META(O)              MkRt(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(MkRuntimeC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MkRuntimeC)
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MkRuntimeC)
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    MK_RT hdl = (MK_RT) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MkRuntimeC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MkRuntimeC##_TT;
 
#define OT_SETUP_hdl_static_constr  OT_SETUP_hdl_static
 
#if !defined(SetupRtFromObj_X)
  #define SetupRtFromObj_X(hdl)     AllRtSetup_X(hdl)
  #define SetupRtFromObj_XN(hdl)    AllRtSetup_XN(hdl)
#endif
 
// MO class
#undef MkRuntimeCTT
#define MkRuntimeCTT MK(MkKernelThreadState).MkRuntimeCTT
/* MkRuntimeC_MK_NULL defined in LibMkKernel_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(MkRuntimeC_CTOR) (MK_RT_ARGS OT_CLS_T type, MK_RT hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,MkRuntimeC_X2obj(hdl));
}
 
// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MkRuntimeC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(MkRuntimeC_selfDelete) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}
// META: called to destroy link from SELF to META
static void NS(MkRuntimeC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}
 
// initialize the PY and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (MkRuntimeCTT == NULL) MkRuntimeCTT = MkRuntimeSTT; \
  \
  /* protect against double call */ \
  if (MkRuntimeCTT->selfCreate == NS(MkRuntimeC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MkRuntimeCTT->selfCreate    = NS(MkRuntimeC_selfCreate); \
  MkRuntimeCTT->selfDelete    = NS(MkRuntimeC_selfDelete); \
  MkRuntimeCTT->selfUnlink    = NS(MkRuntimeC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MkRuntimeCR).tp_base = MkRuntimeC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MkRuntimeC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MkRuntimeC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#define META_CONTEXT_S        MK_ERROR_DEFAULT
 
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkRuntimeC,MkRuntime,sm_,func
#define DebugGet_doc "int32 MkRuntimeC.DebugGet()"
#define DebugSet_doc "MkRuntimeC.DebugSet(dbg:int32)"
#define ErrorGetCode_doc "MkErrorE MkRuntimeC.ErrorGetCode()"
#define IsSilentGet_doc "bool MkRuntimeC.IsSilentGet()"
#define IsSilentSet_doc "MkRuntimeC.IsSilentSet(silent:bool)"
#define Log0_doc "MkRuntimeC.Log0(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogTargetGet_doc "string MkRuntimeC.LogTargetGet()"
#define LogTargetReset_doc "MkRuntimeC.LogTargetReset()"
#define LogTargetSet_doc "MkRuntimeC.LogTargetSet(logTgt:string)"
#define NoDecoSet_doc "MkRuntimeC.NoDecoSet(noDeco:bool)"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
// vim: Marker(m)
 
// ---------------------------------------------------------------------------------------
 
// BEGIN-MkRuntimeC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkRuntimeC,MkRuntimeC-Config,sm_
 
static OT_ProcRet NS(MkRuntimeC_DebugGet) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(DebugGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkRuntimeDebugGet ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_DebugSet) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(DebugSet_doc);
  MK_I32 dbg = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (dbg))
  OT_CHECK_NOARGS;
  MkRuntimeDebugSet (dbg);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_ErrorGetCode) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(ErrorGetCode_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,MkRuntimeErrorGetCode ()));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_IsSilentGet) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(IsSilentGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkRuntimeIsSilentGet ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_IsSilentSet) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(IsSilentSet_doc);
  MK_BOOL silent = 0;
  OT_CHECK_REQUIRED(OT_CHECK_bool (silent))
  OT_CHECK_NOARGS;
  MkRuntimeIsSilentSet (silent);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_LogTargetGet) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(LogTargetGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkRuntimeLogTargetGet ());
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_LogTargetReset) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(LogTargetReset_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(MK_ERROR_FORMAT,MkRuntimeLogTargetReset ());
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_LogTargetSet) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(LogTargetSet_doc);
  MK_STRN logTgt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (logTgt))
  OT_CHECK_NOARGS;
  MkErrorC_Check(MK_ERROR_FORMAT,MkRuntimeLogTargetSet (logTgt));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkRuntimeC_NoDecoSet) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(NoDecoSet_doc);
  MK_BOOL noDeco = 0;
  OT_CHECK_REQUIRED(OT_CHECK_bool (noDeco))
  OT_CHECK_NOARGS;
  MkRuntimeNoDecoSet (noDeco);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkRuntimeC_Config_PY_API
 
 
// doc-key: MkRuntimeC,MkRuntimeC-Info,sm_
 
static OT_ProcRet NS(MkRuntimeC_Log0) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(0,4,Log0_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkRuntimeLog0 (fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkRuntimeC_Info_PY_API
 
// END-MkRuntimeC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
static PyMethodDef MkRuntimeC_Methods[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkRuntimeC,MkRuntime,sm_
  { "DebugGet"       , (PyCFunction) NS(MkRuntimeC_DebugGet)       , METH_NOARGS|METH_CLASS  , DebugGet_doc },
  { "DebugSet"       , (PyCFunction) NS(MkRuntimeC_DebugSet)       , METH_O|METH_CLASS       , DebugSet_doc },
  { "ErrorGetCode"   , (PyCFunction) NS(MkRuntimeC_ErrorGetCode)   , METH_NOARGS|METH_CLASS  , ErrorGetCode_doc },
  { "IsSilentGet"    , (PyCFunction) NS(MkRuntimeC_IsSilentGet)    , METH_NOARGS|METH_CLASS  , IsSilentGet_doc },
  { "IsSilentSet"    , (PyCFunction) NS(MkRuntimeC_IsSilentSet)    , METH_O|METH_CLASS       , IsSilentSet_doc },
  { "Log0"           , (PyCFunction) NS(MkRuntimeC_Log0)           , METH_VARARGS|METH_CLASS , Log0_doc },
  { "LogTargetGet"   , (PyCFunction) NS(MkRuntimeC_LogTargetGet)   , METH_NOARGS|METH_CLASS  , LogTargetGet_doc },
  { "LogTargetReset" , (PyCFunction) NS(MkRuntimeC_LogTargetReset) , METH_NOARGS|METH_CLASS  , LogTargetReset_doc },
  { "LogTargetSet"   , (PyCFunction) NS(MkRuntimeC_LogTargetSet)   , METH_O|METH_CLASS       , LogTargetSet_doc },
  { "NoDecoSet"      , (PyCFunction) NS(MkRuntimeC_NoDecoSet)      , METH_O|METH_CLASS       , NoDecoSet_doc },
 
  // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // → no data
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
OT_CLASS_TYPE_REF NS(MkRuntimeCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymkkernel.MkRuntimeC",
  .tp_doc         = "PyMkKernel MkRuntimeC Type",
  .tp_basicsize   = sizeof(MkRuntimeC_Obj),
  .tp_itemsize    = 0,
  .tp_flags       = Py_TPFLAGS_DEFAULT,
  .tp_methods     = MkRuntimeC_Methods,
  .tp_base        = NULL
};
 
int NS(pMkRuntimeC_Init) ( MK_RT_ARGS PyObject* m)
{
  ClassInit
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap