theKernel 10.0
Loading...
Searching...
No Matches
MkErrorC_py.c
Go to the documentation of this file.
1
9/* LABEL-START */
10
11#define META_FILE_NAME "MkErrorC_py.c"
12
14
15// PY class
16#define OT_CLASS (&NS(MkErrorCR))
17#define OT_CLASS_NAME "MkErrorC"
18
19#define OT_LNG2META(O) MkErr(VAL2MNG(O))
20
21#define OT_retObj_CONSTR(mng) OT_retObj_SET(NS(MkErrorC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
22
23#define OT_SETUP_hdl OT_SETUP_hdl_tmpl(MkErrorC)
24#define OT_SETUP_hdl__null_allow OT_SETUP_hdl_tmpl__null_allow(MkErrorC)
25#define OT_SETUP_hdl_constr MK_RT_UNUSED AllRtSetup_NULL; \
26 MK_ERR hdl = (MK_ERR) OT_CLASS;
27#define OT_SETUP_hdl_destr OT_SETUP_hdl_tmpl__null_allow(MkErrorC)
28#define OT_SETUP_hdl_static MK_RT_UNUSED AllRtSetup_NULL; \
29 __attribute__((unused)) MK_TYP hdl = MkErrorC##_TT;
30
31#define OT_SETUP_hdl_static_constr OT_SETUP_hdl_static
32
33#if !defined(SetupRtFromObj_X)
34 #define SetupRtFromObj_X(hdl) AllRtSetup_X(hdl)
35 #define SetupRtFromObj_XN(hdl) AllRtSetup_XN(hdl)
36#endif
37
38// MO class
39#undef MkErrorCTT
40#define MkErrorCTT MK(MkKernelThreadState).MkErrorCTT
41/* MkErrorC_MK_NULL defined in LibMkKernel_py.h */
42
43__attribute__((unused)) mk_inline
44OT_OBJ_T NS(MkErrorC_CTOR) (MK_RT_ARGS OT_CLS_T type, MK_ERR hdl) {
45 return MK(AtomCreate)(MK_RT_CALL type,MkErrorC_X2obj(hdl));
46}
47
48// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
49
50// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
51static MK_PTR NS(MkErrorC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
52 return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
53}
54// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
55static void NS(MkErrorC_selfDelete) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
56 MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
57}
58// META: called to destroy link from SELF to META
59static void NS(MkErrorC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
60 MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
61 selfO->hdl = NULL;
62}
63
64// initialize the PY and MO class specific object
65#define ClassInit \
66 /* if not already done, initialize NEW META type */ \
67 if (MkErrorCTT == NULL) MkErrorCTT = MkErrorSTT; \
68 \
69 /* protect against double call */ \
70 if (MkErrorCTT->selfCreate == NS(MkErrorC_selfCreate)) return MK_OK; \
71 \
72 /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
73 MkErrorCTT->selfCreate = NS(MkErrorC_selfCreate); \
74 MkErrorCTT->selfDelete = NS(MkErrorC_selfDelete); \
75 MkErrorCTT->selfUnlink = NS(MkErrorC_selfUnlink); \
76 \
77 if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
78 NS(MkErrorCR).tp_base = MkErrorC_base; \
79 OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
80 } \
81 OtErrorCheckLng(PyModule_AddObjectRef(m, "MkErrorC", (PyObject *)OT_CLASS)); \
82 \
83 /* define the "NULL" object */ \
84 MkErrorC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
85
86/* LABEL-END */
87
88#define META_CONTEXT_S hdl
89
90OT_OBJ_T NS(MkErrorC_FormatException) = NULL;
91
92/*****************************************************************************/
93/* */
94/* S T A R T */
95/* */
96/*****************************************************************************/
97
98#define MkErrorCatchTmpl(...) NS(MkExceptionC_Catch)(OT_Prefix_CALL __VA_ARGS__)
99
105
106// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
107
108// doc-key: MkErrorC,MkError,sc_,func
109#define DEFAULT_doc "MkErrorC MkErrorC.DEFAULT()"
110#define FORMAT_doc "MkErrorC MkErrorC.FORMAT(?fmtobj:MkObjectC=None?)"
111#define GetNull_doc "MkErrorC MkErrorC.GetNull()"
112#define HandleResolve_doc "MkErrorC MkErrorC.HandleResolve(netHdl:MK_HDL)"
113#define IGNORE_doc "MkErrorC MkErrorC.IGNORE()"
114#define Instances_doc "MkErrorC MkErrorC.Instances()"
115#define PRINT_doc "MkErrorC MkErrorC.PRINT()"
116
117// doc-key: MkErrorC,MkError,oCx,func
118#define Dup_doc "MkErrorC srce.Dup() (const)"
119
120// doc-key: MkErrorC,MkError,oc_,func
121#define Catch_doc "MkErrorC err.Catch(?exception:errorCode=None?, ?callfunc:string=\"MK_NULL\"?)"
122#define Next_doc "MkErrorC err.Next()"
123#define NoRaise_doc "MkErrorC err.NoRaise()"
124#define Prev_doc "MkErrorC err.Prev()"
125
126// doc-key: MkErrorC,MkError,om_,func
127#define AppendC_doc "err.AppendC(message:string)"
128#define Cleanup_doc "err.Cleanup(?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?)"
129#define Copy_doc "dest.Copy(srce:MkErrorC)"
130#define GetCode_doc "MkErrorE err.GetCode() (const)"
131#define GetNum_doc "int32 err.GetNum() (const)"
132#define GetSize_doc "long err.GetSize() (const)"
133#define GetText_doc "string err.GetText() (const)"
134// skip class-overload: HandleGet → MkObjectHandleGet
135#define IsABORT_doc "bool err.IsABORT() (const)"
136#define IsEXIT_doc "bool err.IsEXIT()"
137#define IsSOCKET_doc "bool err.IsSOCKET() (const)"
138#define IsTIMEOUT_doc "bool err.IsTIMEOUT() (const)"
139// skip class-overload: Log → MkObjectLog
140#define Println_doc "err.Println(?msg:string=\"\"?, ?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?)"
141#define Raise_doc "err.Raise() (const)"
142#define Reset_doc "err.Reset(?callfunc:string=\"MK_NULL\"?, ?callline:int32=-1?, ?force:bool=false?)"
143#define SetABORT_doc "err.SetABORT(?detail:string=\"UNKNOWN\"?, ?callfunc:string=\"MK_NULL\"?)"
144#define SetC_doc "err.SetC(message:string, ?callfunc:string=\"MK_NULL\"?, ?errnum:int32=-1?)"
145#define SetCONTINUE_doc "err.SetCONTINUE()"
146#define SetCode_doc "err.SetCode(code:MkErrorE)"
147#define SetEXIT_doc "err.SetEXIT(?callfunc:string=\"MK_NULL\"?)"
148#define SetSOCKET_doc "err.SetSOCKET(?detail:string=\"UNKNOWN\"?, ?callfunc:string=\"MK_NULL\"?)"
149#define Stack_doc "MkErrorE err.Stack(?callfunc:string=\"MK_NULL\"?, ?callfile:string=\"MK_NULL\"?, ?callline:int32=-1?)"
150#define StackFormat_doc "err.StackFormat(?callfunc:string=\"MK_NULL\"?, ?callfile:string=\"MK_NULL\"?, ?callline:int32=-1?)"
151// skip class-overload: ToString → MkObjectToString
152
153// doc-key: MkErrorC,MkPanic,sm_,func
154#define PanicC_doc "MkErrorC.PanicC(fmtobj:MkObjectC, callfunc:string, errnum:int32, message:string)"
155#define PanicDEFAULT_doc "MkErrorC.PanicDEFAULT(?fmtobj:MkObjectC=None?, ?callfunc:string=\"MK_NULL\"?)"
156
157// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
158
159/*****************************************************************************/
160/* */
161/* error handling functions */
162/* */
163/*****************************************************************************/
164
165/*
166PyObject* NS(ErrorAppend)(
167 MK_STRN doc
168) {
169 if (doc == NULL) return NULL;
170
171 PyObject *expO = PyErr_GetRaisedException();
172 if (expO == NULL) return NULL;
173
174 PyObject *typeO = Py_NewRef(Py_TYPE(expO));
175
176 PyErr_Format(typeO,"%S\n -> found in: %s", expO, doc);
177
178 Py_CLEAR(typeO);
179 Py_CLEAR(expO);
180
181// ------------------------------------------------------
182 if (doc == NULL) return NULL;
183
184 PyObject *typeO = NULL, *valueO=NULL, *tbO = NULL;
185
186 PyErr_Fetch(&typeO,&valueO,&tbO);
187
188 if (valueO) {
189 PyObject *newO = PyUnicode_FromFormat("%S\n -> found in: %s", valueO, doc);
190 if (newO != NULL) {
191 Py_CLEAR(valueO);
192 valueO = newO;
193 }
194 }
195
196MkRtSetup_NULL
197printLngObj(valueO)
198
199 PyErr_Restore(typeO,valueO,tbO);
200
201 return NULL;
202}
203*/
204
210
211// vim: Marker(s)
212// BEGIN-MkErrorC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
213
217
218// doc-key: MkErrorC,MkErrorC-Class-Export,sc_
219
221static OT_ProcRet NS(MkErrorC_HandleResolve) (OtClass_ARGS) {
224 MK_HDL netHdl = 0;
227 MK_ERR retVal = MkErrorHandleResolve (netHdl);
228 OT_retObj_SET_ERR(retVal);
229 goto end;
230 error:
232 end:
234}
235
236// doc-key: MkErrorC,MkErrorC-Class-Export,om_
237
238// skip on class-overload: MkErrorHandleGet → MkObjectHandleGet
240static OT_ProcRet NS(MkErrorC_HandleGet) (MkErrorC_ARGS) {OT_ERROR_LNG_RETURN;}
241
243// MkErrorC_Class_PY_API
244
248
249// doc-key: MkErrorC,MkErrorC-Class-Introspection,oc_
250
252static OT_ProcRet NS(MkErrorC_Next) (MkErrorC_ARGS) {
256 MK_ERR retVal = MkErrorNext (hdl);
257 OT_retObj_SET_ERR(retVal);
258 goto end;
259 error:
261 end:
263}
264
266static OT_ProcRet NS(MkErrorC_Prev) (MkErrorC_ARGS) {
270 MK_ERR retVal = MkErrorPrev (hdl);
271 OT_retObj_SET_ERR(retVal);
272 goto end;
273 error:
275 end:
277}
278
279// doc-key: MkErrorC,MkErrorC-Class-Introspection,sc_
280
282static OT_ProcRet NS(MkErrorC_Instances) (OtClass_ARGS) {
286 MK_ERR retVal = MkErrorInstances ();
287 OT_retObj_SET_ERR(retVal);
288 goto end;
289 error:
291 end:
293}
294
296// MkErrorC_Class_PY_API
297
301
302// doc-key: MkErrorC,MkErrorC-Class-Misc,sc_
303
305static OT_ProcRet NS(MkErrorC_GetNull) (OtClass_ARGS) {
309 MK_ERR retVal = MkErrorGetNull ();
310 OT_retObj_SET_ERR(retVal);
311 goto end;
312 error:
314 end:
316}
317
319// MkErrorC_Class_PY_API
320
324
325// doc-key: MkErrorC,MkErrorC-Get,om_
326
328static OT_ProcRet NS(MkErrorC_GetCode) (MkErrorC_ARGS) {
333 goto end;
334 error:
336 end:
338}
339
341static OT_ProcRet NS(MkErrorC_GetNum) (MkErrorC_ARGS) {
346 goto end;
347 error:
349 end:
351}
352
354static OT_ProcRet NS(MkErrorC_GetSize) (MkErrorC_ARGS) {
359 goto end;
360 error:
362 end:
364}
365
367static OT_ProcRet NS(MkErrorC_GetText) (MkErrorC_ARGS) {
372 goto end;
373 error:
375 end:
377}
378
380// MkErrorC_Get_PY_API
381
385
386// doc-key: MkErrorC,MkErrorC-Misc,oc_
387
389static OT_ProcRet NS(MkErrorC_Catch) (MkErrorC_ARGS) {
392 MK_EXP exception = NULL;
394 MK_STRN callfunc = NULL;
397 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
398 MK_ERR retVal = MkErrorCatchTmpl (hdl, exception, callfunc);
399 OT_retObj_SET_ERR(retVal);
400 goto end;
401 error:
403 end:
406}
407
408// doc-key: MkErrorC,MkErrorC-Misc,om_
409
411static OT_ProcRet NS(MkErrorC_Cleanup) (MkErrorC_ARGS) {
414 MK_STRN callfunc = NULL;
416 MK_I32 callline = -1;
419 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
420 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
421 MkErrorCleanup (hdl, callfunc, callline);
423 goto end;
424 error:
426 end:
429}
430
431// skip on class-overload: MkErrorLog → MkObjectLog
434
436static OT_ProcRet NS(MkErrorC_Println) (MkErrorC_ARGS) {
439 MK_STRN msg = "";
441 MK_STRN callfunc = NULL;
443 MK_I32 callline = -1;
446 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
447 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
448 MkErrorPrintln (hdl, msg, callfunc, callline);
450 goto end;
451 error:
453 end:
456}
457
459static OT_ProcRet NS(MkErrorC_Reset) (MkErrorC_ARGS) {
462 MK_STRN callfunc = NULL;
464 MK_I32 callline = -1;
466 MK_BOOL force = false;
469 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
470 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
471 MkErrorC_Check(hdl,MkErrorReset (hdl, callfunc, callline, force));
473 goto end;
474 error:
476 end:
479}
480
482static OT_ProcRet NS(MkErrorC_Stack) (MkErrorC_ARGS) {
485 MK_STRN callfunc = NULL;
487 MK_STRN callfile = NULL;
489 MK_I32 callline = -1;
492 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
493 if (MkSysStringIsNULL(callfile)) {callfile = OT_GET_CALL_FILE;}
494 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
495 OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,MkErrorStack (hdl, callfunc, callfile, callline)));
496 goto end;
497 error:
499 end:
502}
503
505static OT_ProcRet NS(MkErrorC_StackFormat) (MkErrorC_ARGS) {
508 MK_STRN callfunc = NULL;
510 MK_STRN callfile = NULL;
512 MK_I32 callline = -1;
515 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
516 if (MkSysStringIsNULL(callfile)) {callfile = OT_GET_CALL_FILE;}
517 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
518 MkErrorStackFormat (hdl, callfunc, callfile, callline);
520 goto end;
521 error:
523 end:
526}
527
528// skip on class-overload: MkErrorToString → MkObjectToString
530static OT_ProcRet NS(MkErrorC_ToString) (MkErrorC_ARGS) {OT_ERROR_LNG_RETURN;}
531
533// MkErrorC_Misc_PY_API
534
538
539// doc-key: MkErrorC,MkErrorC-Raise,oc_
540
542static OT_ProcRet NS(MkErrorC_NoRaise) (MkErrorC_ARGS) {
546 MK_ERR retVal = MkErrorNoRaise (hdl);
547 OT_retObj_SET_ERR(retVal);
548 goto end;
549 error:
551 end:
553}
554
555// doc-key: MkErrorC,MkErrorC-Raise,om_
556
558static OT_ProcRet NS(MkErrorC_AppendC) (MkErrorC_ARGS) {
561 MK_STRN message = 0;
564 MkErrorAppendC (hdl, message);
566 goto end;
567 error:
569 end:
571}
572
574static OT_ProcRet NS(MkErrorC_Raise) (MkErrorC_ARGS) {
578 MkErrorC_Check(hdl,MkErrorRaise (hdl));
580 goto end;
581 error:
583 end:
585}
586
588static OT_ProcRet NS(MkErrorC_SetC) (MkErrorC_ARGS) {
591 MK_STRN message = 0;
593 MK_STRN callfunc = NULL;
595 MK_I32 errnum = -1;
598 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
599 MkErrorC_Check(hdl,MkErrorSetC (hdl, message, callfunc, errnum));
601 goto end;
602 error:
604 end:
607}
608
609// doc-key: MkErrorC,MkErrorC-Raise,sm_
610
612static OT_ProcRet NS(MkErrorC_PanicC) (OtClass_ARGS) {
615 MK_OBJN fmtobj = NULL;
617 MK_STRN callfunc = NULL;
619 MK_I32 errnum = -1;
621 MK_STRN message = 0;
624 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
625 MkPanicC (fmtobj, callfunc, errnum, message);
627 goto end;
628 error:
630 end:
633}
634
636static OT_ProcRet NS(MkErrorC_PanicDEFAULT) (OtClass_ARGS) {
639 MK_OBJN fmtobj = NULL;
641 MK_STRN callfunc = NULL;
644 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
645 MkPanicDEFAULT (fmtobj, callfunc);
647 goto end;
648 error:
650 end:
653}
654
656// MkErrorC_Raise_PY_API
657
661
662// doc-key: MkErrorC,MkErrorC-Signal,om_
663
665static OT_ProcRet NS(MkErrorC_IsABORT) (MkErrorC_ARGS) {
670 goto end;
671 error:
673 end:
675}
676
678static OT_ProcRet NS(MkErrorC_IsEXIT) (MkErrorC_ARGS) {
683 goto end;
684 error:
686 end:
688}
689
691static OT_ProcRet NS(MkErrorC_IsSOCKET) (MkErrorC_ARGS) {
696 goto end;
697 error:
699 end:
701}
702
704static OT_ProcRet NS(MkErrorC_IsTIMEOUT) (MkErrorC_ARGS) {
709 goto end;
710 error:
712 end:
714}
715
717static OT_ProcRet NS(MkErrorC_SetABORT) (MkErrorC_ARGS) {
720 MK_STRN detail = "UNKNOWN";
722 MK_STRN callfunc = NULL;
725 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
726 MkErrorC_Check(hdl,MkErrorSetABORT (hdl, detail, callfunc));
728 goto end;
729 error:
731 end:
734}
735
737static OT_ProcRet NS(MkErrorC_SetCONTINUE) (MkErrorC_ARGS) {
741 MkErrorSetCONTINUE (hdl);
743 goto end;
744 error:
746 end:
748}
749
751static OT_ProcRet NS(MkErrorC_SetCode) (MkErrorC_ARGS) {
754 enum MkErrorE code = 0;
757 MkErrorSetCode (hdl, code);
759 goto end;
760 error:
762 end:
764}
765
767static OT_ProcRet NS(MkErrorC_SetEXIT) (MkErrorC_ARGS) {
770 MK_STRN callfunc = NULL;
773 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
774 MkErrorC_Check(hdl,MkErrorSetEXIT (hdl, callfunc));
776 goto end;
777 error:
779 end:
782}
783
785static OT_ProcRet NS(MkErrorC_SetSOCKET) (MkErrorC_ARGS) {
788 MK_STRN detail = "UNKNOWN";
790 MK_STRN callfunc = NULL;
793 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
794 MkErrorC_Check(hdl,MkErrorSetSOCKET (hdl, detail, callfunc));
796 goto end;
797 error:
799 end:
802}
803
805// MkErrorC_Signal_PY_API
806
810
811// doc-key: MkErrorC,MkErrorC-System,sc_
812
814static OT_ProcRet NS(MkErrorC_DEFAULT) (OtClass_ARGS) {
818 MK_ERR retVal = MkErrorDEFAULT ();
819 OT_retObj_SET_ERR(retVal);
820 goto end;
821 error:
823 end:
825}
826
828static OT_ProcRet NS(MkErrorC_FORMAT) (OtClass_ARGS) {
831 MK_OBJN fmtobj = NULL;
834 MK_ERR retVal = MkErrorFORMAT (fmtobj);
835 OT_retObj_SET_ERR(retVal);
836 goto end;
837 error:
839 end:
841}
842
844static OT_ProcRet NS(MkErrorC_IGNORE) (OtClass_ARGS) {
848 MK_ERR retVal = MkErrorIGNORE ();
849 OT_retObj_SET_ERR(retVal);
850 goto end;
851 error:
853 end:
855}
856
858static OT_ProcRet NS(MkErrorC_PRINT) (OtClass_ARGS) {
862 MK_ERR retVal = MkErrorPRINT ();
863 OT_retObj_SET_ERR(retVal);
864 goto end;
865 error:
867 end:
869}
870
872// MkErrorC_System_PY_API
873
877
878// doc-key: MkErrorC,MkErrorC-TOR,oCx
879
881static OT_ProcRet NS(MkErrorC_Dup) (MkErrorC_ARGS) {
885 MK_ERR retVal = MkErrorDup (hdl);
886 if (retVal == NULL) {
887 OT_ERROR_CONSTRUCTOR(MkErrorC);
888 goto error;
889 }
890 OT_retObj_SET_ERR(retVal);
891 goto end;
892 error:
894 end:
896}
897
898// doc-key: MkErrorC,MkErrorC-TOR,om_
899
901static OT_ProcRet NS(MkErrorC_Copy) (MkErrorC_ARGS) {
904 MK_ERRN srce = 0;
907 MkErrorCopy (hdl, srce);
909 goto end;
910 error:
912 end:
914}
915
917// MkErrorC_TOR_PY_API
918
919// END-MkErrorC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
920
926
927static PyMethodDef NS(MkErrorC_Methods)[] = {
928
929 // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
930
931 // doc-key: MkErrorC,MkError,sc_
932 { "DEFAULT" , (PyCFunction) NS(MkErrorC_DEFAULT) , METH_NOARGS|METH_CLASS , DEFAULT_doc },
933 { "FORMAT" , (PyCFunction) NS(MkErrorC_FORMAT) , METH_VARARGS|METH_CLASS , FORMAT_doc },
934 { "GetNull" , (PyCFunction) NS(MkErrorC_GetNull) , METH_NOARGS|METH_CLASS , GetNull_doc },
935 { "HandleResolve" , (PyCFunction) NS(MkErrorC_HandleResolve) , METH_O|METH_CLASS , HandleResolve_doc },
936 { "IGNORE" , (PyCFunction) NS(MkErrorC_IGNORE) , METH_NOARGS|METH_CLASS , IGNORE_doc },
937 { "Instances" , (PyCFunction) NS(MkErrorC_Instances) , METH_NOARGS|METH_CLASS , Instances_doc },
938 { "PRINT" , (PyCFunction) NS(MkErrorC_PRINT) , METH_NOARGS|METH_CLASS , PRINT_doc },
939
940 // doc-key: MkErrorC,MkPanic,sm_
941 { "PanicC" , (PyCFunction) NS(MkErrorC_PanicC) , METH_VARARGS|METH_CLASS , PanicC_doc },
942 { "PanicDEFAULT" , (PyCFunction) NS(MkErrorC_PanicDEFAULT) , METH_VARARGS|METH_CLASS , PanicDEFAULT_doc },
943
944 // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
945
946 // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
947
948 // doc-key: MkErrorC,MkError,oCx
949 { "Dup" , (PyCFunction) NS(MkErrorC_Dup) , METH_NOARGS , Dup_doc },
950
951 // doc-key: MkErrorC,MkError,oc_
952 { "Catch" , (PyCFunction) NS(MkErrorC_Catch) , METH_VARARGS , Catch_doc },
953 { "Next" , (PyCFunction) NS(MkErrorC_Next) , METH_NOARGS , Next_doc },
954 { "NoRaise" , (PyCFunction) NS(MkErrorC_NoRaise) , METH_NOARGS , NoRaise_doc },
955 { "Prev" , (PyCFunction) NS(MkErrorC_Prev) , METH_NOARGS , Prev_doc },
956
957 // doc-key: MkErrorC,MkError,om_
958 { "AppendC" , (PyCFunction) NS(MkErrorC_AppendC) , METH_O , AppendC_doc },
959 { "Cleanup" , (PyCFunction) NS(MkErrorC_Cleanup) , METH_VARARGS , Cleanup_doc },
960 { "Copy" , (PyCFunction) NS(MkErrorC_Copy) , METH_O , Copy_doc },
961 { "GetCode" , (PyCFunction) NS(MkErrorC_GetCode) , METH_NOARGS , GetCode_doc },
962 { "GetNum" , (PyCFunction) NS(MkErrorC_GetNum) , METH_NOARGS , GetNum_doc },
963 { "GetSize" , (PyCFunction) NS(MkErrorC_GetSize) , METH_NOARGS , GetSize_doc },
964 { "GetText" , (PyCFunction) NS(MkErrorC_GetText) , METH_NOARGS , GetText_doc },
965 // skip class-overload: MkErrorHandleGet → HandleGet, NS(MkErrorC_HandleGet)
966 { "IsABORT" , (PyCFunction) NS(MkErrorC_IsABORT) , METH_NOARGS , IsABORT_doc },
967 { "IsEXIT" , (PyCFunction) NS(MkErrorC_IsEXIT) , METH_NOARGS , IsEXIT_doc },
968 { "IsSOCKET" , (PyCFunction) NS(MkErrorC_IsSOCKET) , METH_NOARGS , IsSOCKET_doc },
969 { "IsTIMEOUT" , (PyCFunction) NS(MkErrorC_IsTIMEOUT) , METH_NOARGS , IsTIMEOUT_doc },
970 // skip class-overload: MkErrorLog → Log, NS(MkErrorC_Log)
971 { "Println" , (PyCFunction) NS(MkErrorC_Println) , METH_VARARGS , Println_doc },
972 { "Raise" , (PyCFunction) NS(MkErrorC_Raise) , METH_NOARGS , Raise_doc },
973 { "Reset" , (PyCFunction) NS(MkErrorC_Reset) , METH_VARARGS , Reset_doc },
974 { "SetABORT" , (PyCFunction) NS(MkErrorC_SetABORT) , METH_VARARGS , SetABORT_doc },
975 { "SetC" , (PyCFunction) NS(MkErrorC_SetC) , METH_VARARGS , SetC_doc },
976 { "SetCONTINUE" , (PyCFunction) NS(MkErrorC_SetCONTINUE) , METH_NOARGS , SetCONTINUE_doc },
977 { "SetCode" , (PyCFunction) NS(MkErrorC_SetCode) , METH_O , SetCode_doc },
978 { "SetEXIT" , (PyCFunction) NS(MkErrorC_SetEXIT) , METH_VARARGS , SetEXIT_doc },
979 { "SetSOCKET" , (PyCFunction) NS(MkErrorC_SetSOCKET) , METH_VARARGS , SetSOCKET_doc },
980 { "Stack" , (PyCFunction) NS(MkErrorC_Stack) , METH_VARARGS , Stack_doc },
981 { "StackFormat" , (PyCFunction) NS(MkErrorC_StackFormat) , METH_VARARGS , StackFormat_doc },
982 // skip class-overload: MkErrorToString → ToString, NS(MkErrorC_ToString)
983
984 // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
985
986 {NULL, NULL, 0, NULL} /* Sentinel */
987};
988
990 PyVarObject_HEAD_INIT(NULL, 0)
991 .tp_name = "pymkkernel.MkErrorC",
992 .tp_doc = "PyMkKernel MkErrorC Type",
993 .tp_basicsize = sizeof(MkErrorC_Obj),
994 .tp_itemsize = 0,
995 .tp_methods = NS(MkErrorC_Methods),
996 .tp_flags = Py_TPFLAGS_DEFAULT,
997 .tp_base = NULL
998 };
999
1005
1006// script2code.tcl MkErrorC.py > MkErrorC.tpl
1007static const char MkErrorC_code[]=
1008 #include "MkErrorC.tpl"
1009;
1010
1011int NS(pMkErrorC_Init) ( MK_RT_ARGS PyObject* m)
1012{
1013 ClassInit
1014
1015 MkErrorDefaultC_TT->selfCreate = NS(MkErrorC_selfCreate);
1016 MkErrorDefaultC_TT->selfDelete = NS(MkErrorC_selfDelete);
1017 MkErrorDefaultC_TT->selfUnlink = NS(MkErrorC_selfUnlink);
1018
1019 OT_OBJ_T globalD = PyDict_New();
1020 OT_OBJ_T compO = Py_CompileString(MkErrorC_code,"MkErrorC.py",Py_file_input);
1021 if (compO == NULL) goto error2;
1022 OT_OBJ_T localD = PyModule_GetDict(NS(pymkkernel));
1023 if (localD == NULL) goto error2;
1024 OT_OBJ_T retO = PyEval_EvalCode(compO,globalD,localD);
1025 if (retO == NULL) goto error2;
1026 Py_CLEAR(retO);
1027 Py_CLEAR(compO);
1028 NS(MkErrorC_FormatException) = PyObject_GetAttrString(NS(pymkkernel),"MkErrorC_FormatException");
1029 if (NS(MkErrorC_FormatException) == NULL) goto error2;
1030
1031 return 0;
1032error:
1033 return -1;
1034error2:
1035 if (PyErr_Occurred()) {
1036 PyErr_Print();
1037 }
1038 return -1;
1039}
1040
1041// vim: nowrap
tag: nhi1-release-250425
#define OT_CHECK_bool(val)
#define OT_SELF
#define MK(n)
struct MkErrorC_Obj MkErrorC_Obj
#define OT_SETUP_VARARGS(min, max, d)
#define OT_retObj_SET_BOL(nat)
#define OT_SETUP_NOARG(d)
#define OT_SETUP_ONEARG(d)
#define OT_ERROR_LNG_RETURN
#define OT_CHECK_NI4(val)
#define OT_retObj_SET_Error
#define OT_GET_CALL_LINE
#define OT_FRAME_CLEANUP
#define OT_ERROR_CONSTRUCTOR(class)
#define OT_retObj_SET_LONG(nat)
#define OT_CHECK_REQUIRED(val)
#define OT_retObj_SET_None
#define OT_retObj_SET_I32(nat)
#define OT_GET_CALL_FILE
PyTypeObject * OT_CLS_T
#define NS(n)
#define OT_retObj_RETURN
#define OT_GET_CALL_PROC
PyObject * OT_OBJ_T
#define OT_retObj_SET_STR(nat)
#define OT_CLASS_TYPE_REF
#define OT_NEW_Mk_enum_OBJ(typ, val)
#define OT_CHECK_OPTIONAL(val)
#define OT_retObj_SET_ERR(nat)
#define MkErrorC_ARGS
#define OT_retObj_SET(val)
#define OT_CHECK_NOARGS
#define MkErrorC_Check(mng, PROC)
#define OT_ProcRet
#define OtClass_ARGS
#define OT_CHECK_STRN(val)
#define Instances_doc
#define SetSOCKET_doc
#define Stack_doc
#define StackFormat_doc
#define PanicDEFAULT_doc
#define GetText_doc
#define DEFAULT_doc
#define Reset_doc
#define IsABORT_doc
#define Raise_doc
#define OT_SETUP_hdl
Definition MkErrorC_py.c:23
#define SetEXIT_doc
#define NoRaise_doc
static const char MkErrorC_code[]
#define SetC_doc
#define Dup_doc
#define Catch_doc
#define IsSOCKET_doc
#define GetNull_doc
#define SetABORT_doc
#define Next_doc
#define GetSize_doc
#define SetCode_doc
#define GetCode_doc
#define HandleResolve_doc
#define Prev_doc
#define OT_CLASS
Definition MkErrorC_py.c:16
#define Println_doc
#define OT_SETUP_hdl_static
Definition MkErrorC_py.c:28
#define MkErrorCatchTmpl(...)
Definition MkErrorC_py.c:98
#define IsEXIT_doc
#define GetNum_doc
#define IGNORE_doc
#define IsTIMEOUT_doc
#define OT_SETUP_hdl__null_allow
Definition MkErrorC_py.c:24
#define FORMAT_doc
#define Cleanup_doc
#define SetCONTINUE_doc
#define PanicC_doc
#define PRINT_doc
#define AppendC_doc
#define ClassInit
Definition MkErrorC_py.c:65
#define Copy_doc
static MK_ERR MkErrorNext(MK_ERR const err)
get next instance from linked-list of MkErrorS type
#define MkErrorHandleResolve(...)
static MK_ERR MkErrorGetNull(void)
Null-Slot - return a MkErrorC typed NULL instance …
static MK_ERR MkErrorPrev(MK_ERR const err)
get previous instance from linked-list of MkErrorS type
#define MkErrorInstances()
#define MkErrorC_X2obj(x)
#define MkErrorGetSizeI(e)
get the error-message-size from the exception-object …
#define MkErrorGetCodeI(e)
get the value of MkErrorS::code …
#define MkErrorGetTextI(e)
get the MkErrorS::text …
#define MkErrorGetNumI(e)
get the MkErrorS::num. The number can be used as exit-code …
#define MkErrorStackFormat(...)
#define MkErrorPrintln(...)
#define MkErrorCleanup(...)
#define MkErrorStack(...)
#define MkErrorReset(...)
#define MkErrorSetC(...)
#define MkPanicDEFAULT(...)
#define MkErrorRaise(...)
#define MkPanicC(...)
#define MkErrorAppendC(...)
#define MkErrorNoRaise(...)
bool MkErrorIsSOCKET(MK_ERRN const err)
check on SOCKET-DOWN error …
bool MkErrorIsABORT(MK_ERRN const err)
check on ABORT signal …
bool MkErrorIsEXIT(MK_ERR const err)
check on APPLICATION-EXIT error …
#define MkErrorSetCONTINUE(...)
bool MkErrorIsTIMEOUT(MK_ERRN const err)
check on TIMEOUT error …
#define MkErrorSetCode(...)
#define MkErrorSetEXIT(...)
#define MkErrorSetSOCKET(...)
#define MkErrorSetABORT(...)
#define MkErrorIGNORE()
#define MkErrorDEFAULT()
#define MkErrorPRINT()
MK_ERR MkErrorFORMAT(MK_OBJN fmtobj)
system-error-format - format and return the default-error …
#define MkErrorCopy(...)
#define MkErrorDup(...)
#define MkErrorDefaultC_TT
class as MkTypeS-class-type, useable in a class-macro as: class##_TT …
#define mk_inline
#define MK_NULL_NO
flag, not allow NULL
#define MK_NULL_YES
flag, allow NULL
#define MK_UNUSED
mark unnused variables and functions
#define MK_DEPRECATED
MkErrorE
collection for the different error-codes …
MK_PTRB * MK_PTR
generic pointer data-type
const MK_STRB * MK_STRN
constant string pointer data-type
MK_PTRB const * MK_EXP
exception object pointer
bool MK_BOOL
real bool data-type
int32_t MK_HDL
4 byte int handle data-type
signed int MK_I32
4 byte integer data-type
static bool MkSysStringIsNULL(MK_STRN str)
test if string is NULL or EMPTY …
#define MK_RT_CALL
#define MK_RT_ARGS
#define OT_CHECK_NIH(val)
#define OT_CHECK_ERRN(val, nullB)
#define OT_CHECK_ENUM(ename, val)
#define OT_CHECK_OBJN(val, nullB)
#define OT_CHECK_EXP(val)
The data-type to store and handle the error-condition …
PyObject_HEAD MK_OBJ hdl
object header …