tag: nhi1-release-250425 More...

#include "LibMkKernel_private_py.h"
#include "MkErrorC.tpl"

Include dependency graph for MkErrorC_py.c:

Macros
#define	META_FILE_NAME "MkErrorC_py.c"

#define	OT_CLASS (&NS(MkErrorCR))

#define	OT_CLASS_NAME "MkErrorC"

#define	OT_LNG2META(O)

#define	OT_retObj_CONSTR(mng)

#define	OT_SETUP_hdl OT_SETUP_hdl_tmpl(MkErrorC)

#define	OT_SETUP_hdl__null_allow OT_SETUP_hdl_tmpl__null_allow(MkErrorC)

#define	OT_SETUP_hdl_constr

#define	OT_SETUP_hdl_destr OT_SETUP_hdl_tmpl__null_allow(MkErrorC)

#define	OT_SETUP_hdl_static

#define	OT_SETUP_hdl_static_constr OT_SETUP_hdl_static

#define	SetupRtFromObj_X(hdl)

#define	SetupRtFromObj_XN(hdl)

#define	MkErrorCTT MK(MkKernelThreadState).MkErrorCTT

#define	ClassInit

#define	META_CONTEXT_S hdl

#define	MkErrorCatchTmpl(...)

#define	DEFAULT_doc "MkErrorC MkErrorC.DEFAULT()"

#define	FORMAT_doc "MkErrorC MkErrorC.FORMAT(?fmtobj:MkObjectC=None?)"

#define	GetNull_doc "MkErrorC MkErrorC.GetNull()"

#define	HandleResolve_doc "MkErrorC MkErrorC.HandleResolve(netHdl:MK_HDL)"

#define	IGNORE_doc "MkErrorC MkErrorC.IGNORE()"

#define	Instances_doc "MkErrorC MkErrorC.Instances()"

#define	PRINT_doc "MkErrorC MkErrorC.PRINT()"

#define	Dup_doc "MkErrorC srce.Dup() (const)"

#define	Catch_doc "MkErrorC err.Catch(?exception:errorCode=None?, ?callfunc:string=\"MK_NULL\"?)"

#define	Next_doc "MkErrorC err.Next()"

#define	NoRaise_doc "MkErrorC err.NoRaise()"

#define	Prev_doc "MkErrorC err.Prev()"

#define	AppendC_doc "err.AppendC(message:string)"

#define	Cleanup_doc "err.Cleanup(?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?)"

#define	Copy_doc "dest.Copy(srce:MkErrorC)"

#define	GetCode_doc "MkErrorE err.GetCode() (const)"

#define	GetNum_doc "int32 err.GetNum() (const)"

#define	GetSize_doc "long err.GetSize() (const)"

#define	GetText_doc "string err.GetText() (const)"

#define	IsABORT_doc "bool err.IsABORT() (const)"

#define	IsEXIT_doc "bool err.IsEXIT()"

#define	IsSOCKET_doc "bool err.IsSOCKET() (const)"

#define	IsTIMEOUT_doc "bool err.IsTIMEOUT() (const)"

#define	Println_doc "err.Println(?msg:string=\"\"?, ?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?)"

#define	Raise_doc "err.Raise() (const)"

#define	Reset_doc "err.Reset(?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?, ?force:bool=false?)"

#define	SetABORT_doc "err.SetABORT(?detail:string=\"UNKNOWN\"?, ?callfunc:string=\"MK_NULL\"?)"

#define	SetC_doc "err.SetC(message:string, ?callfunc:string=\"MK_NULL\"?, ?errnum:int32=-1?)"

#define	SetCONTINUE_doc "err.SetCONTINUE()"

#define	SetCode_doc "err.SetCode(code:MkErrorE)"

#define	SetEXIT_doc "err.SetEXIT(?callfunc:string=\"MK_NULL\"?)"

#define	SetSOCKET_doc "err.SetSOCKET(?detail:string=\"UNKNOWN\"?, ?callfunc:string=\"MK_NULL\"?)"

#define	Stack_doc "MkErrorE err.Stack(?callfunc:string=\"MK_NULL\"?, ?callfile:string=\"MK_NULL\"?, ?callline:int32=-1?)"

#define	StackFormat_doc "err.StackFormat(?callfunc:string=\"MK_NULL\"?, ?callfile:string=\"MK_NULL\"?, ?callline:int32=-1?)"

#define	PanicC_doc "MkErrorC.PanicC(fmtobj:MkObjectC, callfunc:string, errnum:int32, message:string)"

#define	PanicDEFAULT_doc "MkErrorC.PanicDEFAULT(?fmtobj:MkObjectC=None?, ?callfunc:string=\"MK_NULL\"?)"

Functions
static OT_OBJ_T	pymkkernel_MkErrorC_CTOR (MK_RT mkrt, OT_CLS_T type, MK_ERR hdl)

static MK_PTR	pymkkernel_MkErrorC_selfCreate (MK_RT mkrt, MK_OBJ const obj, MK_PTR const env)

static void	pymkkernel_MkErrorC_selfDelete (MK_RT mkrt, MK_PTR self, MK_PTR const env)

static void	pymkkernel_MkErrorC_selfUnlink (MK_RT mkrt, MK_PTR self, MK_PTR const env)

static OT_ProcRet	pymkkernel_MkErrorC_HandleResolve (OtClass_ARGS)
	`Python: [static] MkErrorC MkErrorC.HandleResolve(netHdl:MK_HDL)` → C-API Handle-Resolve-Slot - return a MkErrorC from *netHdl* or `None` if invalid…

MK_DEPRECATED static MK_UNUSED OT_ProcRet	pymkkernel_MkErrorC_HandleGet (MkErrorC_ARGS)

static OT_ProcRet	pymkkernel_MkErrorC_Next (MkErrorC_ARGS)
	`Python: MkErrorC err.Next()` → C-API get next instance from linked-list of MkErrorS type

static OT_ProcRet	pymkkernel_MkErrorC_Prev (MkErrorC_ARGS)
	`Python: MkErrorC err.Prev()` → C-API get previous instance from linked-list of MkErrorS type

static OT_ProcRet	pymkkernel_MkErrorC_Instances (OtClass_ARGS)
	`Python: [static] MkErrorC MkErrorC.Instances()` → C-API get head-instance from linked-list of MkErrorS type …

static OT_ProcRet	pymkkernel_MkErrorC_GetNull (OtClass_ARGS)
	`Python: [static] MkErrorC MkErrorC.GetNull()` → C-API Null-Slot - return a MkErrorC typed `NULL` instance …

static OT_ProcRet	pymkkernel_MkErrorC_GetCode (MkErrorC_ARGS)
	`Python: MkErrorE err.GetCode()` → C-API get the value of MkErrorS::code …

static OT_ProcRet	pymkkernel_MkErrorC_GetNum (MkErrorC_ARGS)
	`Python: int32 err.GetNum()` → C-API get the MkErrorS::num. The number can be used as exit-code …

static OT_ProcRet	pymkkernel_MkErrorC_GetSize (MkErrorC_ARGS)
	`Python: long err.GetSize()` → C-API get the error-message-size from the exception-object …

static OT_ProcRet	pymkkernel_MkErrorC_GetText (MkErrorC_ARGS)
	`Python: string err.GetText()` → C-API get the MkErrorS::text …

static OT_ProcRet	pymkkernel_MkErrorC_Catch (MkErrorC_ARGS)
	`Python: MkErrorC err.Catch(?exception:errorCode=None?, ?callfunc:string="MK_NULL"?)` → C-API convert a programming-language-error into an pymkkernel error …

static OT_ProcRet	pymkkernel_MkErrorC_Cleanup (MkErrorC_ARGS)
	`Python: err.Cleanup(?callfunc:string="MK_NULL"?, ?callline:int32=-1?)` → C-API cleanup and print unwanted active error …

MK_DEPRECATED static MK_UNUSED OT_ProcRet	pymkkernel_MkErrorC_Log (MkErrorC_ARGS)

static OT_ProcRet	pymkkernel_MkErrorC_Println (MkErrorC_ARGS)
	`Python: err.Println(?msg:string=""?, ?callfunc:string="MK_NULL"?, ?callline:int32=-1?)` → C-API print the default-error to the MkLogFileC (default: stderr) and clear the error afterwards …

static OT_ProcRet	pymkkernel_MkErrorC_Reset (MkErrorC_ARGS)
	`Python: err.Reset(?callfunc:string="MK_NULL"?, ?callline:int32=-1?, ?force:bool=false?)` → C-API This function clears the err and resets to MK_OK …

static OT_ProcRet	pymkkernel_MkErrorC_Stack (MkErrorC_ARGS)
	`Python: MkErrorE err.Stack(?callfunc:string="MK_NULL"?, ?callfile:string="MK_NULL"?, ?callline:int32=-1?)` → C-API check on error and if yes append an ErrorStackFormat to the error-message …

static OT_ProcRet	pymkkernel_MkErrorC_StackFormat (MkErrorC_ARGS)
	`Python: err.StackFormat(?callfunc:string="MK_NULL"?, ?callfile:string="MK_NULL"?, ?callline:int32=-1?)` → C-API append an ensemble of func, file and line to the error-message …

MK_DEPRECATED static MK_UNUSED OT_ProcRet	pymkkernel_MkErrorC_ToString (MkErrorC_ARGS)

static OT_ProcRet	pymkkernel_MkErrorC_NoRaise (MkErrorC_ARGS)
	`Python: MkErrorC err.NoRaise()` → C-API ignore the next return of MK_ERROR and do not raise an target-language-exception …

static OT_ProcRet	pymkkernel_MkErrorC_AppendC (MkErrorC_ARGS)
	`Python: err.AppendC(message:string)` → C-API append the message to the MkErrorS::text …

static OT_ProcRet	pymkkernel_MkErrorC_Raise (MkErrorC_ARGS)
	`Python: err.Raise()` → C-API convert an pymkkernel error into an programming-language-error and raise afterwards. …

static OT_ProcRet	pymkkernel_MkErrorC_SetC (MkErrorC_ARGS)
	`Python: err.SetC(message:string, ?callfunc:string="MK_NULL"?, ?errnum:int32=-1?)` → C-API 'set' and 'raise' the MkErrorC using a string-message and a errnum-number …

static OT_ProcRet	pymkkernel_MkErrorC_PanicC (OtClass_ARGS)
	`Python: [static] MkErrorC.PanicC(fmtobj:MkObjectC, callfunc:string, errnum:int32, message:string)` → C-API do a panic with string as argument …

static OT_ProcRet	pymkkernel_MkErrorC_PanicDEFAULT (OtClass_ARGS)
	`Python: [static] MkErrorC.PanicDEFAULT(?fmtobj:MkObjectC=None?, ?callfunc:string="MK_NULL"?)` → C-API make panic from MkErrorDEFAULT_RT …

static OT_ProcRet	pymkkernel_MkErrorC_IsABORT (MkErrorC_ARGS)
	`Python: bool err.IsABORT()` → C-API check on *ABORT* signal …

static OT_ProcRet	pymkkernel_MkErrorC_IsEXIT (MkErrorC_ARGS)
	`Python: bool err.IsEXIT()` → C-API check on APPLICATION-EXIT error …

static OT_ProcRet	pymkkernel_MkErrorC_IsSOCKET (MkErrorC_ARGS)
	`Python: bool err.IsSOCKET()` → C-API check on SOCKET-DOWN error …

static OT_ProcRet	pymkkernel_MkErrorC_IsTIMEOUT (MkErrorC_ARGS)
	`Python: bool err.IsTIMEOUT()` → C-API check on *TIMEOUT* error …

static OT_ProcRet	pymkkernel_MkErrorC_SetABORT (MkErrorC_ARGS)
	`Python: err.SetABORT(?detail:string="UNKNOWN"?, ?callfunc:string="MK_NULL"?)` → C-API send the *ABORT* signal to the calling stack…

static OT_ProcRet	pymkkernel_MkErrorC_SetCONTINUE (MkErrorC_ARGS)
	`Python: err.SetCONTINUE()` → C-API signal end of processing in an MqMqEventIF callback …

static OT_ProcRet	pymkkernel_MkErrorC_SetCode (MkErrorC_ARGS)
	`Python: err.SetCode(code:MkErrorE)` → C-API set the MkErrorS::code value …

static OT_ProcRet	pymkkernel_MkErrorC_SetEXIT (MkErrorC_ARGS)
	`Python: err.SetEXIT(?callfunc:string="MK_NULL"?)` → C-API finish the current callback, return to toplevel and MqExit the application …

static OT_ProcRet	pymkkernel_MkErrorC_SetSOCKET (MkErrorC_ARGS)
	`Python: err.SetSOCKET(?detail:string="UNKNOWN"?, ?callfunc:string="MK_NULL"?)` → C-API create SOCKET-DOWN error …

static OT_ProcRet	pymkkernel_MkErrorC_DEFAULT (OtClass_ARGS)
	`Python: [static] MkErrorC MkErrorC.DEFAULT()` → C-API default-system-error - default-error …

static OT_ProcRet	pymkkernel_MkErrorC_FORMAT (OtClass_ARGS)
	`Python: [static] MkErrorC MkErrorC.FORMAT(?fmtobj:MkObjectC=None?)` → C-API system-error-format - format and return the default-error …

static OT_ProcRet	pymkkernel_MkErrorC_IGNORE (OtClass_ARGS)
	`Python: [static] MkErrorC MkErrorC.IGNORE()` → C-API ignore-system-error - ignore the next error …

static OT_ProcRet	pymkkernel_MkErrorC_PRINT (OtClass_ARGS)
	`Python: [static] MkErrorC MkErrorC.PRINT()` → C-API ignore-system-error - print the next error into MkLogFileC …

static OT_ProcRet	pymkkernel_MkErrorC_Dup (MkErrorC_ARGS)
	`Python: [constructor] MkErrorC srce.Dup()` → C-API Dup-Constructor - create a new MkErrorC instance as copy from an existing MkErrorC instance …

static OT_ProcRet	pymkkernel_MkErrorC_Copy (MkErrorC_ARGS)
	`Python: dest.Copy(srce:MkErrorC)` → C-API Copy-Constructor - sync an existing MkErrorC instance with the values from an existing MkErrorC instance …

int	pymkkernel_pMkErrorC_Init (MK_RT mkrt, PyObject *m)

Variables
OT_OBJ_T	pymkkernel_MkErrorC_FormatException = NULL

static PyMethodDef	pymkkernel_MkErrorC_Methods []

OT_CLASS_TYPE_REF	pymkkernel_MkErrorCR

static const char	MkErrorC_code [] =

Detailed Description

tag: nhi1-release-250425

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

Definition in file MkErrorC_py.c.

Macro Definition Documentation

◆ AppendC_doc

#define AppendC_doc "err.AppendC(message:string)"

Definition at line 127 of file MkErrorC_py.c.

◆ Catch_doc

#define Catch_doc "MkErrorC err.Catch(?exception:errorCode=None?, ?callfunc:string=\"MK_NULL\"?)"

Definition at line 121 of file MkErrorC_py.c.

◆ ClassInit

#define ClassInit

Value:

  /* if not already done, initialize NEW META type */ \
  if (MkErrorCTT == NULL) MkErrorCTT = MkErrorSTT; \
  \
  /* protect against double call */ \
  if (MkErrorCTT->selfCreate == NS(MkErrorC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MkErrorCTT->selfCreate    = NS(MkErrorC_selfCreate); \
  MkErrorCTT->selfDelete    = NS(MkErrorC_selfDelete); \
  MkErrorCTT->selfUnlink    = NS(MkErrorC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MkErrorCR).tp_base = MkErrorC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MkErrorC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MkErrorC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));

Definition at line 65 of file MkErrorC_py.c.

#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (MkErrorCTT == NULL) MkErrorCTT = MkErrorSTT; \
  \
  /* protect against double call */ \
  if (MkErrorCTT->selfCreate == NS(MkErrorC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MkErrorCTT->selfCreate    = NS(MkErrorC_selfCreate); \
  MkErrorCTT->selfDelete    = NS(MkErrorC_selfDelete); \
  MkErrorCTT->selfUnlink    = NS(MkErrorC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MkErrorCR).tp_base = MkErrorC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MkErrorC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MkErrorC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));

◆ Cleanup_doc

#define Cleanup_doc "err.Cleanup(?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?)"

Definition at line 128 of file MkErrorC_py.c.

◆ Copy_doc

#define Copy_doc "dest.Copy(srce:MkErrorC)"

Definition at line 129 of file MkErrorC_py.c.

◆ DEFAULT_doc

#define DEFAULT_doc "MkErrorC MkErrorC.DEFAULT()"

doc definition

Definition at line 109 of file MkErrorC_py.c.

◆ Dup_doc

#define Dup_doc "MkErrorC srce.Dup() (const)"

Definition at line 118 of file MkErrorC_py.c.

◆ FORMAT_doc

#define FORMAT_doc "MkErrorC MkErrorC.FORMAT(?fmtobj:MkObjectC=None?)"

Definition at line 110 of file MkErrorC_py.c.

◆ GetCode_doc

#define GetCode_doc "MkErrorE err.GetCode() (const)"

Definition at line 130 of file MkErrorC_py.c.

◆ GetNull_doc

#define GetNull_doc "MkErrorC MkErrorC.GetNull()"

Definition at line 111 of file MkErrorC_py.c.

◆ GetNum_doc

#define GetNum_doc "int32 err.GetNum() (const)"

Definition at line 131 of file MkErrorC_py.c.

◆ GetSize_doc

#define GetSize_doc "long err.GetSize() (const)"

Definition at line 132 of file MkErrorC_py.c.

◆ GetText_doc

#define GetText_doc "string err.GetText() (const)"

Definition at line 133 of file MkErrorC_py.c.

◆ HandleResolve_doc

#define HandleResolve_doc "MkErrorC MkErrorC.HandleResolve(netHdl:MK_HDL)"

Definition at line 112 of file MkErrorC_py.c.

◆ IGNORE_doc

#define IGNORE_doc "MkErrorC MkErrorC.IGNORE()"

Definition at line 113 of file MkErrorC_py.c.

◆ Instances_doc

#define Instances_doc "MkErrorC MkErrorC.Instances()"

Definition at line 114 of file MkErrorC_py.c.

◆ IsABORT_doc

#define IsABORT_doc "bool err.IsABORT() (const)"

Definition at line 135 of file MkErrorC_py.c.

◆ IsEXIT_doc

#define IsEXIT_doc "bool err.IsEXIT()"

Definition at line 136 of file MkErrorC_py.c.

◆ IsSOCKET_doc

#define IsSOCKET_doc "bool err.IsSOCKET() (const)"

Definition at line 137 of file MkErrorC_py.c.

◆ IsTIMEOUT_doc

#define IsTIMEOUT_doc "bool err.IsTIMEOUT() (const)"

Definition at line 138 of file MkErrorC_py.c.

◆ META_CONTEXT_S

#define META_CONTEXT_S hdl

Definition at line 88 of file MkErrorC_py.c.

◆ META_FILE_NAME

#define META_FILE_NAME "MkErrorC_py.c"

Definition at line 11 of file MkErrorC_py.c.

◆ MkErrorCatchTmpl

#define MkErrorCatchTmpl ( ... )

Value:

NS(MkExceptionC_Catch)(OT_Prefix_CALL __VA_ARGS__)

OT_Prefix_CALL

#define OT_Prefix_CALL

Definition LibMkKernel_py.h:602

Definition at line 98 of file MkErrorC_py.c.

◆ MkErrorCTT

#define MkErrorCTT MK(MkKernelThreadState).MkErrorCTT

Definition at line 40 of file MkErrorC_py.c.

◆ Next_doc

#define Next_doc "MkErrorC err.Next()"

Definition at line 122 of file MkErrorC_py.c.

◆ NoRaise_doc

#define NoRaise_doc "MkErrorC err.NoRaise()"

Definition at line 123 of file MkErrorC_py.c.

◆ OT_CLASS

#define OT_CLASS (&NS(MkErrorCR))

Definition at line 16 of file MkErrorC_py.c.

◆ OT_CLASS_NAME

#define OT_CLASS_NAME "MkErrorC"

Definition at line 17 of file MkErrorC_py.c.

◆ OT_LNG2META

#define OT_LNG2META ( O )

Value:

MkErr(VAL2MNG(O))

VAL2MNG

#define VAL2MNG(val)

Definition LibMkKernel_py.h:860

MkErr

static MK_ERR MkErr(MK_MNG mng)

cast a unknown-object into an MkErrorS pointer or NULL if not possible

Definition LibMkKernel_mk.h:9825

Definition at line 19 of file MkErrorC_py.c.

◆ OT_retObj_CONSTR

#define OT_retObj_CONSTR ( mng )

Value:

OT_retObj_SET(NS(MkErrorC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))

OT_retObj_SET

#define OT_retObj_SET(val)

Definition LibMkKernel_py.h:499

Definition at line 21 of file MkErrorC_py.c.

◆ OT_SETUP_hdl

#define OT_SETUP_hdl OT_SETUP_hdl_tmpl(MkErrorC)

Definition at line 23 of file MkErrorC_py.c.

◆ OT_SETUP_hdl__null_allow

#define OT_SETUP_hdl__null_allow OT_SETUP_hdl_tmpl__null_allow(MkErrorC)

Definition at line 24 of file MkErrorC_py.c.

◆ OT_SETUP_hdl_constr

#define OT_SETUP_hdl_constr

Value:

MK_RT_UNUSED AllRtSetup_NULL; \

MK_ERR hdl = (MK_ERR) OT_CLASS;

MK_ERR

struct MkErrorS * MK_ERR

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

Definition LibMkKernel_mk.h:1576

AllRtSetup_NULL

#define AllRtSetup_NULL

Definition LibMkKernel_mk.h:12457

MK_RT_UNUSED

#define MK_RT_UNUSED

Definition LibMkKernel_mk.h:904

Definition at line 25 of file MkErrorC_py.c.

25#define OT_SETUP_hdl_constr MK_RT_UNUSED AllRtSetup_NULL; \

26 MK_ERR hdl = (MK_ERR) OT_CLASS;

◆ OT_SETUP_hdl_destr

#define OT_SETUP_hdl_destr OT_SETUP_hdl_tmpl__null_allow(MkErrorC)

Definition at line 27 of file MkErrorC_py.c.

◆ OT_SETUP_hdl_static

#define OT_SETUP_hdl_static

Value:

MK_RT_UNUSED AllRtSetup_NULL; \

__attribute__((unused)) MK_TYP hdl = MkErrorC##_TT;

MkTypeS

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

Definition LibMkKernel_mk.h:3945

Definition at line 28 of file MkErrorC_py.c.

28#define OT_SETUP_hdl_static MK_RT_UNUSED AllRtSetup_NULL; \

29 __attribute__((unused)) MK_TYP hdl = MkErrorC##_TT;

◆ OT_SETUP_hdl_static_constr

#define OT_SETUP_hdl_static_constr OT_SETUP_hdl_static

Definition at line 31 of file MkErrorC_py.c.

◆ PanicC_doc

#define PanicC_doc "MkErrorC.PanicC(fmtobj:MkObjectC, callfunc:string, errnum:int32, message:string)"

Definition at line 154 of file MkErrorC_py.c.

◆ PanicDEFAULT_doc

#define PanicDEFAULT_doc "MkErrorC.PanicDEFAULT(?fmtobj:MkObjectC=None?, ?callfunc:string=\"MK_NULL\"?)"

Definition at line 155 of file MkErrorC_py.c.

◆ Prev_doc

#define Prev_doc "MkErrorC err.Prev()"

Definition at line 124 of file MkErrorC_py.c.

◆ PRINT_doc

#define PRINT_doc "MkErrorC MkErrorC.PRINT()"

Definition at line 115 of file MkErrorC_py.c.

◆ Println_doc

#define Println_doc "err.Println(?msg:string=\"\"?, ?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?)"

Definition at line 140 of file MkErrorC_py.c.

◆ Raise_doc

#define Raise_doc "err.Raise() (const)"

Definition at line 141 of file MkErrorC_py.c.

◆ Reset_doc

#define Reset_doc "err.Reset(?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?, ?force:bool=false?)"

Definition at line 142 of file MkErrorC_py.c.

◆ SetABORT_doc

#define SetABORT_doc "err.SetABORT(?detail:string=\"UNKNOWN\"?, ?callfunc:string=\"MK_NULL\"?)"

Definition at line 143 of file MkErrorC_py.c.

◆ SetC_doc

#define SetC_doc "err.SetC(message:string, ?callfunc:string=\"MK_NULL\"?, ?errnum:int32=-1?)"

Definition at line 144 of file MkErrorC_py.c.

◆ SetCode_doc

#define SetCode_doc "err.SetCode(code:MkErrorE)"

Definition at line 146 of file MkErrorC_py.c.

◆ SetCONTINUE_doc

#define SetCONTINUE_doc "err.SetCONTINUE()"

Definition at line 145 of file MkErrorC_py.c.

◆ SetEXIT_doc

#define SetEXIT_doc "err.SetEXIT(?callfunc:string=\"MK_NULL\"?)"

Definition at line 147 of file MkErrorC_py.c.

◆ SetSOCKET_doc

#define SetSOCKET_doc "err.SetSOCKET(?detail:string=\"UNKNOWN\"?, ?callfunc:string=\"MK_NULL\"?)"

Definition at line 148 of file MkErrorC_py.c.

◆ SetupRtFromObj_X

#define SetupRtFromObj_X ( hdl )

Value:

AllRtSetup_X(hdl)

AllRtSetup_X

#define AllRtSetup_X(x)

Definition LibMkKernel_mk.h:12455

Definition at line 34 of file MkErrorC_py.c.

◆ SetupRtFromObj_XN

#define SetupRtFromObj_XN ( hdl )

Value:

AllRtSetup_XN(hdl)

AllRtSetup_XN

#define AllRtSetup_XN(x)

Definition LibMkKernel_mk.h:12456

Definition at line 35 of file MkErrorC_py.c.

◆ Stack_doc

#define Stack_doc "MkErrorE err.Stack(?callfunc:string=\"MK_NULL\"?, ?callfile:string=\"MK_NULL\"?, ?callline:int32=-1?)"

Definition at line 149 of file MkErrorC_py.c.

◆ StackFormat_doc

#define StackFormat_doc "err.StackFormat(?callfunc:string=\"MK_NULL\"?, ?callfile:string=\"MK_NULL\"?, ?callline:int32=-1?)"

Definition at line 150 of file MkErrorC_py.c.

Function Documentation

◆ pymkkernel_MkErrorC_CTOR()

static OT_OBJ_T pymkkernel_MkErrorC_CTOR	(	MK_RT	mkrt,
		OT_CLS_T	type,
		MK_ERR	hdl )

inlinestatic

Definition at line 44 of file MkErrorC_py.c.

                                                                  {
  return MK(AtomCreate)(MK_RT_CALL type,MkErrorC_X2obj(hdl));
}

◆ pymkkernel_MkErrorC_selfCreate()

static MK_PTR pymkkernel_MkErrorC_selfCreate	(	MK_RT	mkrt,
		MK_OBJ const	obj,
		MK_PTR const	env )

static

Definition at line 51 of file MkErrorC_py.c.

                                                                                      {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}

◆ pymkkernel_MkErrorC_selfDelete()

static void pymkkernel_MkErrorC_selfDelete	(	MK_RT	mkrt,
		MK_PTR	self,
		MK_PTR const	env )

static

Definition at line 55 of file MkErrorC_py.c.

                                                                               {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}

◆ pymkkernel_MkErrorC_selfUnlink()

static void pymkkernel_MkErrorC_selfUnlink	(	MK_RT	mkrt,
		MK_PTR	self,
		MK_PTR const	env )

static

Definition at line 59 of file MkErrorC_py.c.

                                                                               {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}

◆ pymkkernel_pMkErrorC_Init()

int pymkkernel_pMkErrorC_Init	(	MK_RT	mkrt,
		PyObject *	m )

Definition at line 1011 of file MkErrorC_py.c.

{
  ClassInit
 
  MkErrorDefaultC_TT->selfCreate    = NS(MkErrorC_selfCreate);
  MkErrorDefaultC_TT->selfDelete    = NS(MkErrorC_selfDelete);
  MkErrorDefaultC_TT->selfUnlink    = NS(MkErrorC_selfUnlink);
 
  OT_OBJ_T globalD = PyDict_New();
  OT_OBJ_T compO = Py_CompileString(MkErrorC_code,"MkErrorC.py",Py_file_input);
  if (compO == NULL) goto error2;
  OT_OBJ_T localD = PyModule_GetDict(NS(pymkkernel));
  if (localD == NULL) goto error2;
  OT_OBJ_T retO = PyEval_EvalCode(compO,globalD,localD);
  if (retO == NULL) goto error2;
  Py_CLEAR(retO);
  Py_CLEAR(compO);
  NS(MkErrorC_FormatException) = PyObject_GetAttrString(NS(pymkkernel),"MkErrorC_FormatException");
  if (NS(MkErrorC_FormatException) == NULL) goto error2;
 
  return 0;
error:
  return -1;
error2:
  if (PyErr_Occurred()) {
      PyErr_Print();
  }
  return -1;
}

Variable Documentation

◆ MkErrorC_code

const char MkErrorC_code[] =

static

Public API

Definition at line 1007 of file MkErrorC_py.c.

◆ pymkkernel_MkErrorC_FormatException

OT_OBJ_T pymkkernel_MkErrorC_FormatException = NULL

Definition at line 90 of file MkErrorC_py.c.

◆ pymkkernel_MkErrorC_Methods

PyMethodDef pymkkernel_MkErrorC_Methods[]

static

Object definition

Definition at line 927 of file MkErrorC_py.c.

                                            {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkErrorC,MkError,sc_
  { "DEFAULT"       , (PyCFunction) NS(MkErrorC_DEFAULT)       , METH_NOARGS|METH_CLASS  , DEFAULT_doc },
  { "FORMAT"        , (PyCFunction) NS(MkErrorC_FORMAT)        , METH_VARARGS|METH_CLASS , FORMAT_doc },
  { "GetNull"       , (PyCFunction) NS(MkErrorC_GetNull)       , METH_NOARGS|METH_CLASS  , GetNull_doc },
  { "HandleResolve" , (PyCFunction) NS(MkErrorC_HandleResolve) , METH_O|METH_CLASS       , HandleResolve_doc },
  { "IGNORE"        , (PyCFunction) NS(MkErrorC_IGNORE)        , METH_NOARGS|METH_CLASS  , IGNORE_doc },
  { "Instances"     , (PyCFunction) NS(MkErrorC_Instances)     , METH_NOARGS|METH_CLASS  , Instances_doc },
  { "PRINT"         , (PyCFunction) NS(MkErrorC_PRINT)         , METH_NOARGS|METH_CLASS  , PRINT_doc },
 
  // doc-key: MkErrorC,MkPanic,sm_
  { "PanicC"        , (PyCFunction) NS(MkErrorC_PanicC)        , METH_VARARGS|METH_CLASS , PanicC_doc },
  { "PanicDEFAULT"  , (PyCFunction) NS(MkErrorC_PanicDEFAULT)  , METH_VARARGS|METH_CLASS , PanicDEFAULT_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
 
  // doc-key: MkErrorC,MkError,oCx
  { "Dup"           , (PyCFunction) NS(MkErrorC_Dup)           , METH_NOARGS             , Dup_doc },
 
  // doc-key: MkErrorC,MkError,oc_
  { "Catch"         , (PyCFunction) NS(MkErrorC_Catch)         , METH_VARARGS            , Catch_doc },
  { "Next"          , (PyCFunction) NS(MkErrorC_Next)          , METH_NOARGS             , Next_doc },
  { "NoRaise"       , (PyCFunction) NS(MkErrorC_NoRaise)       , METH_NOARGS             , NoRaise_doc },
  { "Prev"          , (PyCFunction) NS(MkErrorC_Prev)          , METH_NOARGS             , Prev_doc },
 
  // doc-key: MkErrorC,MkError,om_
  { "AppendC"       , (PyCFunction) NS(MkErrorC_AppendC)       , METH_O                  , AppendC_doc },
  { "Cleanup"       , (PyCFunction) NS(MkErrorC_Cleanup)       , METH_VARARGS            , Cleanup_doc },
  { "Copy"          , (PyCFunction) NS(MkErrorC_Copy)          , METH_O                  , Copy_doc },
  { "GetCode"       , (PyCFunction) NS(MkErrorC_GetCode)       , METH_NOARGS             , GetCode_doc },
  { "GetNum"        , (PyCFunction) NS(MkErrorC_GetNum)        , METH_NOARGS             , GetNum_doc },
  { "GetSize"       , (PyCFunction) NS(MkErrorC_GetSize)       , METH_NOARGS             , GetSize_doc },
  { "GetText"       , (PyCFunction) NS(MkErrorC_GetText)       , METH_NOARGS             , GetText_doc },
  // skip class-overload: MkErrorHandleGet → HandleGet, NS(MkErrorC_HandleGet)
  { "IsABORT"       , (PyCFunction) NS(MkErrorC_IsABORT)       , METH_NOARGS             , IsABORT_doc },
  { "IsEXIT"        , (PyCFunction) NS(MkErrorC_IsEXIT)        , METH_NOARGS             , IsEXIT_doc },
  { "IsSOCKET"      , (PyCFunction) NS(MkErrorC_IsSOCKET)      , METH_NOARGS             , IsSOCKET_doc },
  { "IsTIMEOUT"     , (PyCFunction) NS(MkErrorC_IsTIMEOUT)     , METH_NOARGS             , IsTIMEOUT_doc },
  // skip class-overload: MkErrorLog → Log, NS(MkErrorC_Log)
  { "Println"       , (PyCFunction) NS(MkErrorC_Println)       , METH_VARARGS            , Println_doc },
  { "Raise"         , (PyCFunction) NS(MkErrorC_Raise)         , METH_NOARGS             , Raise_doc },
  { "Reset"         , (PyCFunction) NS(MkErrorC_Reset)         , METH_VARARGS            , Reset_doc },
  { "SetABORT"      , (PyCFunction) NS(MkErrorC_SetABORT)      , METH_VARARGS            , SetABORT_doc },
  { "SetC"          , (PyCFunction) NS(MkErrorC_SetC)          , METH_VARARGS            , SetC_doc },
  { "SetCONTINUE"   , (PyCFunction) NS(MkErrorC_SetCONTINUE)   , METH_NOARGS             , SetCONTINUE_doc },
  { "SetCode"       , (PyCFunction) NS(MkErrorC_SetCode)       , METH_O                  , SetCode_doc },
  { "SetEXIT"       , (PyCFunction) NS(MkErrorC_SetEXIT)       , METH_VARARGS            , SetEXIT_doc },
  { "SetSOCKET"     , (PyCFunction) NS(MkErrorC_SetSOCKET)     , METH_VARARGS            , SetSOCKET_doc },
  { "Stack"         , (PyCFunction) NS(MkErrorC_Stack)         , METH_VARARGS            , Stack_doc },
  { "StackFormat"   , (PyCFunction) NS(MkErrorC_StackFormat)   , METH_VARARGS            , StackFormat_doc },
  // skip class-overload: MkErrorToString → ToString, NS(MkErrorC_ToString)
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

◆ pymkkernel_MkErrorCR

OT_CLASS_TYPE_REF pymkkernel_MkErrorCR

Initial value:

= {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name        = "pymkkernel.MkErrorC",
    .tp_doc         = "PyMkKernel MkErrorC Type",
    .tp_basicsize   = sizeof(MkErrorC_Obj),
    .tp_itemsize    = 0,
    .tp_methods     =  pymkkernel_MkErrorC_Methods ,
    .tp_flags       = Py_TPFLAGS_DEFAULT,
    .tp_base        = NULL
  }

Definition at line 989 of file MkErrorC_py.c.

                                  {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name        = "pymkkernel.MkErrorC",
    .tp_doc         = "PyMkKernel MkErrorC Type",
    .tp_basicsize   = sizeof(MkErrorC_Obj),
    .tp_itemsize    = 0,
    .tp_methods     = NS(MkErrorC_Methods),
    .tp_flags       = Py_TPFLAGS_DEFAULT,
    .tp_base        = NULL
  };

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ AppendC_doc

◆ Catch_doc

◆ ClassInit

◆ Cleanup_doc

◆ Copy_doc

◆ DEFAULT_doc

◆ Dup_doc

◆ FORMAT_doc

◆ GetCode_doc

◆ GetNull_doc

◆ GetNum_doc

◆ GetSize_doc

◆ GetText_doc

◆ HandleResolve_doc

◆ IGNORE_doc

◆ Instances_doc

◆ IsABORT_doc

◆ IsEXIT_doc

◆ IsSOCKET_doc

◆ IsTIMEOUT_doc

◆ META_CONTEXT_S

◆ META_FILE_NAME

◆ MkErrorCatchTmpl

◆ MkErrorCTT

◆ Next_doc

◆ NoRaise_doc

◆ OT_CLASS

◆ OT_CLASS_NAME

◆ OT_LNG2META

◆ OT_retObj_CONSTR

◆ OT_SETUP_hdl

◆ OT_SETUP_hdl__null_allow

◆ OT_SETUP_hdl_constr

◆ OT_SETUP_hdl_destr

◆ OT_SETUP_hdl_static

◆ OT_SETUP_hdl_static_constr

◆ PanicC_doc

◆ PanicDEFAULT_doc

◆ Prev_doc

◆ PRINT_doc

◆ Println_doc

◆ Raise_doc

◆ Reset_doc

◆ SetABORT_doc

◆ SetC_doc

◆ SetCode_doc

◆ SetCONTINUE_doc

◆ SetEXIT_doc

◆ SetSOCKET_doc

◆ SetupRtFromObj_X

◆ SetupRtFromObj_XN

◆ Stack_doc

◆ StackFormat_doc

Function Documentation

◆ pymkkernel_MkErrorC_CTOR()

◆ pymkkernel_MkErrorC_selfCreate()

◆ pymkkernel_MkErrorC_selfDelete()

◆ pymkkernel_MkErrorC_selfUnlink()

◆ pymkkernel_pMkErrorC_Init()

Variable Documentation

◆ MkErrorC_code

◆ pymkkernel_MkErrorC_FormatException

◆ pymkkernel_MkErrorC_Methods

◆ pymkkernel_MkErrorCR