theKernel 10.0
Loading...
Searching...
No Matches
MkErrorC_rb.c
Go to the documentation of this file.
1
9/* LABEL-START */
10#define META_FILE_NAME "MkErrorC_rb.c"
11
13
14#define OT_CLASS NS(MkErrorC)
15#define OT_CLASS_NAME "MkErrorC"
16
17#define OT_LNG2META(O) MkErr(VAL2MNG(O))
18
20
21// new Class type object
22static MK_TYP MkErrorCTT = NULL;
24
25// GS marker in "Data_Wrap_Struct"
26static void NS(sMark) (MK_PTR);
27
28// ruby datatype of the wrapped struct
29static rb_data_type_t NS(MkErrorC_T) = {
30 "MkErrorC",
31 {
32 NS(sMark),
33 MK(AtomDeleteSoft),
34 0, /* dsize */
35 0, /* reserved[1] */
36 },
37 NULL, /* parent */
38 NULL, /* data */
39 RUBY_TYPED_FREE_IMMEDIATELY
40};
41
42// >>THIS<< is a Phase-1-CONSTRUCTOR: a constructor which create the SELF object
43// A Phase-2-CONSTRUCTOR is a constructor which configure an already existing object
44// DO: create a new SELF and link this SELF with the MQ-Object "mng"
45// clazz is the toplevel "subclass" or "MkErrorC"
46mk_inline OT_OBJ_T NS(LNG_CONSTR) (OT_CLS_T clazz, MK_MNG mng, int objc, VALUE* objv) {
47 return MK(AtomObjCrt)(clazz,&NS(MkErrorC_T),mng,objc,objv);
48}
49// MQ: ObjNew feature: called to return a new or an already existing RUBY-SELF-Object
50// -> moved to: msgque_rb.h
51// OT_OBJ_T NS(MkErrorC_ObjNew) (MK_ERR hdl) {
52// return MK(AtomObjNew) (MkErrorC_X2obj(hdl));
53// }
54// MQ: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
55static MK_PTR NS(MkErrorC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
56 OT_OBJ_T self = NS(LNG_CONSTR) (OT_CLASS, obj, 0, NULL);
57 return VAL2PTR(self);
58}
59// MQ: called on instance-destruction for a "selfCreate" instance → goal: destroy the SELF
60static void NS(MkErrorC_selfDelete) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
62}
63// MQ: called to destroy link from SELF to META
64static void NS(MkErrorC_selfUnlink) (MK_RT_ARGS MK_PTR ptr, MK_PTR envP) {
65 OT_OBJ_T self = PTR2VAL(ptr);
66 RDATA(self)->data = NULL;
67}
68// initialize the RUBY and MO class specific object
69#define S_INIT NS(sInit)(MK_RT_CALL_ONLY)
70static void NS(sInit)(MK_RT_ARGS_ONLY) {
71
72 // add "selfCreate" and "selfDelete" feature to the MQ-MkErrorC-Type
73 MkErrorCTT->selfCreate = NS(MkErrorC_selfCreate);
74 MkErrorCTT->selfDelete = NS(MkErrorC_selfDelete);
75 MkErrorCTT->selfUnlink = NS(MkErrorC_selfUnlink);
76
77 // create the RUBY class
78 OT_CLASS = rb_define_class_under(OT_PKG, "MkErrorC", MK_BASE_CLASS);
79 rb_undef_alloc_func(OT_CLASS);
80
81 /* define the "NULL" object */
82 VALUE nullO = TypedData_Wrap_Struct (OT_CLASS, &NS(MkErrorC_T), MK_NULL);
83 NS(MkErrorC_MK_NULL) = nullO;
85}
86
87#define OT_SETUP_hdl OT_SETUP_hdl_tmpl(MkErrorC);
88#define OT_SETUP_hdl__null_allow OT_SETUP_hdl_tmpl__null_allow(MkErrorC);
89#define OT_SETUP_hdl_constr AllRtSetup_NULL; \
90 OT_OBJ_T clazz = self; \
91 MkErrorC_type hdl = (MkErrorC_type) &MkERROR;
92#define OT_SETUP_hdl_destr OT_SETUP_hdl_tmpl__null_allow(MkErrorC);
93#define OT_SETUP_hdl_static AllRtSetup_NULL; \
94 __attribute__((unused)) MK_TYP hdl = MkErrorC##_TT;
95#define OT_SETUP_hdl_static_constr OT_SETUP_hdl_static
96
97#if !defined(SetupRtFromObj_X)
98 #define SetupRtFromObj_X(hdl) AllRtSetup_X(hdl)
99 #define SetupRtFromObj_XN(hdl) AllRtSetup_XN(hdl)
100#endif
101
102/* LABEL-END */
103
104OT_CLS_T MK(MkErrorC);
105
106// BEGIN-DOC - created by 'rb_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=nil?)"
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=nil?, ?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=nil?, ?callfunc:string=\"MK_NULL\"?)"
156
157// END-DOC - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
158
159// ---------------------------------------------------------------------------------------
160
166
167// ---------------------------------------------------------------------------------------
168
169// catch ignore MkErrorE
170#define MkErrorCatchTmpl(...) MK(MkExceptionC_Catch)(OT_Prefix_CALL __VA_ARGS__, NULL)
171
172// BEGIN-MkErrorC - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
173
177
178// doc-key: MkErrorC,MkErrorC-Class-Export,sc_
179
181static OT_ProcRet NS(MkErrorC_HandleResolve) (OtClass_ARGS) {
184 MK_HDL netHdl = 0;
187 MK_ERR retVal = MkErrorHandleResolve (netHdl);
188 OT_retObj_SET_ERR(retVal);
189 end: MK_UNUSED /* LONG JUMP on error */
191}
192
193// doc-key: MkErrorC,MkErrorC-Class-Export,om_
194
195// skip on class-overload: MkErrorHandleGet → MkObjectHandleGet
197static OT_ProcRet NS(MkErrorC_HandleGet) (MkErrorC_ARGS) {OT_ERROR_LNG_RETURN;}
198
200// MkErrorC_Class_RB_API
201
205
206// doc-key: MkErrorC,MkErrorC-Class-Introspection,oc_
207
209static OT_ProcRet NS(MkErrorC_Next) (MkErrorC_ARGS) {
213 MK_ERR retVal = MkErrorNext (hdl);
214 OT_retObj_SET_ERR(retVal);
215 end: MK_UNUSED /* LONG JUMP on error */
217}
218
220static OT_ProcRet NS(MkErrorC_Prev) (MkErrorC_ARGS) {
224 MK_ERR retVal = MkErrorPrev (hdl);
225 OT_retObj_SET_ERR(retVal);
226 end: MK_UNUSED /* LONG JUMP on error */
228}
229
230// doc-key: MkErrorC,MkErrorC-Class-Introspection,sc_
231
233static OT_ProcRet NS(MkErrorC_Instances) (OtClass_ARGS) {
237 MK_ERR retVal = MkErrorInstances ();
238 OT_retObj_SET_ERR(retVal);
239 end: MK_UNUSED /* LONG JUMP on error */
241}
242
244// MkErrorC_Class_RB_API
245
249
250// doc-key: MkErrorC,MkErrorC-Class-Misc,sc_
251
253static OT_ProcRet NS(MkErrorC_GetNull) (OtClass_ARGS) {
257 MK_ERR retVal = MkErrorGetNull ();
258 OT_retObj_SET_ERR(retVal);
259 end: MK_UNUSED /* LONG JUMP on error */
261}
262
264// MkErrorC_Class_RB_API
265
269
270// doc-key: MkErrorC,MkErrorC-Get,om_
271
273static OT_ProcRet NS(MkErrorC_GetCode) (MkErrorC_ARGS) {
278 end: MK_UNUSED /* LONG JUMP on error */
280}
281
283static OT_ProcRet NS(MkErrorC_GetNum) (MkErrorC_ARGS) {
288 end: MK_UNUSED /* LONG JUMP on error */
290}
291
293static OT_ProcRet NS(MkErrorC_GetSize) (MkErrorC_ARGS) {
298 end: MK_UNUSED /* LONG JUMP on error */
300}
301
303static OT_ProcRet NS(MkErrorC_GetText) (MkErrorC_ARGS) {
308 end: MK_UNUSED /* LONG JUMP on error */
310}
311
313// MkErrorC_Get_RB_API
314
318
319// doc-key: MkErrorC,MkErrorC-Misc,oc_
320
322static OT_ProcRet NS(MkErrorC_Catch) (MkErrorC_ARGS) {
325 MK_EXP exception = NULL;
327 MK_STRN callfunc = NULL;
330 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
331 MK_ERR retVal = MkErrorCatchTmpl (hdl, exception, callfunc);
332 OT_retObj_SET_ERR(retVal);
333 end: MK_UNUSED /* LONG JUMP on error */
336}
337
338// doc-key: MkErrorC,MkErrorC-Misc,om_
339
341static OT_ProcRet NS(MkErrorC_Cleanup) (MkErrorC_ARGS) {
344 MK_STRN callfunc = NULL;
346 MK_I32 callline = -1;
349 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
350 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
351 MkErrorCleanup (hdl, callfunc, callline);
353 end: MK_UNUSED /* LONG JUMP on error */
356}
357
358// skip on class-overload: MkErrorLog → MkObjectLog
361
363static OT_ProcRet NS(MkErrorC_Println) (MkErrorC_ARGS) {
366 MK_STRN msg = "";
368 MK_STRN callfunc = NULL;
370 MK_I32 callline = -1;
373 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
374 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
375 MkErrorPrintln (hdl, msg, callfunc, callline);
377 end: MK_UNUSED /* LONG JUMP on error */
380}
381
383static OT_ProcRet NS(MkErrorC_Reset) (MkErrorC_ARGS) {
386 MK_STRN callfunc = NULL;
388 MK_I32 callline = -1;
390 MK_BOOL force = false;
393 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
394 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
395 MkErrorC_Check(hdl,MkErrorReset (hdl, callfunc, callline, force));
397 end: MK_UNUSED /* LONG JUMP on error */
400}
401
403static OT_ProcRet NS(MkErrorC_Stack) (MkErrorC_ARGS) {
406 MK_STRN callfunc = NULL;
408 MK_STRN callfile = NULL;
410 MK_I32 callline = -1;
413 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
414 if (MkSysStringIsNULL(callfile)) {callfile = OT_GET_CALL_FILE;}
415 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
416 OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,MkErrorStack (hdl, callfunc, callfile, callline)));
417 end: MK_UNUSED /* LONG JUMP on error */
420}
421
423static OT_ProcRet NS(MkErrorC_StackFormat) (MkErrorC_ARGS) {
426 MK_STRN callfunc = NULL;
428 MK_STRN callfile = NULL;
430 MK_I32 callline = -1;
433 if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
434 if (MkSysStringIsNULL(callfile)) {callfile = OT_GET_CALL_FILE;}
435 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
436 MkErrorStackFormat (hdl, callfunc, callfile, callline);
438 end: MK_UNUSED /* LONG JUMP on error */
441}
442
443// skip on class-overload: MkErrorToString → MkObjectToString
445static OT_ProcRet NS(MkErrorC_ToString) (MkErrorC_ARGS) {OT_ERROR_LNG_RETURN;}
446
448// MkErrorC_Misc_RB_API
449
453
454// doc-key: MkErrorC,MkErrorC-Raise,oc_
455
457static OT_ProcRet NS(MkErrorC_NoRaise) (MkErrorC_ARGS) {
461 MK_ERR retVal = MkErrorNoRaise (hdl);
462 OT_retObj_SET_ERR(retVal);
463 end: MK_UNUSED /* LONG JUMP on error */
465}
466
467// doc-key: MkErrorC,MkErrorC-Raise,om_
468
470static OT_ProcRet NS(MkErrorC_AppendC) (MkErrorC_ARGS) {
473 MK_STRN message = 0;
476 MkErrorAppendC (hdl, message);
478 end: MK_UNUSED /* LONG JUMP on error */
480}
481
483static OT_ProcRet NS(MkErrorC_Raise) (MkErrorC_ARGS) {
487 MkErrorC_Check(hdl,MkErrorRaise (hdl));
489 end: MK_UNUSED /* LONG JUMP on error */
491}
492
494static OT_ProcRet NS(MkErrorC_SetC) (MkErrorC_ARGS) {
497 MK_STRN message = 0;
499 MK_STRN callfunc = NULL;
501 MK_I32 errnum = -1;
504 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
505 MkErrorC_Check(hdl,MkErrorSetC (hdl, message, callfunc, errnum));
507 end: MK_UNUSED /* LONG JUMP on error */
510}
511
512// doc-key: MkErrorC,MkErrorC-Raise,sm_
513
515static OT_ProcRet NS(MkErrorC_PanicC) (OtClass_ARGS) {
518 MK_OBJN fmtobj = NULL;
520 MK_STRN callfunc = NULL;
522 MK_I32 errnum = -1;
524 MK_STRN message = 0;
527 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
528 MkPanicC (fmtobj, callfunc, errnum, message);
530 end: MK_UNUSED /* LONG JUMP on error */
533}
534
536static OT_ProcRet NS(MkErrorC_PanicDEFAULT) (OtClass_ARGS) {
539 MK_OBJN fmtobj = NULL;
541 MK_STRN callfunc = NULL;
544 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
545 MkPanicDEFAULT (fmtobj, callfunc);
547 end: MK_UNUSED /* LONG JUMP on error */
550}
551
553// MkErrorC_Raise_RB_API
554
558
559// doc-key: MkErrorC,MkErrorC-Signal,om_
560
562static OT_ProcRet NS(MkErrorC_IsABORT) (MkErrorC_ARGS) {
567 end: MK_UNUSED /* LONG JUMP on error */
569}
570
572static OT_ProcRet NS(MkErrorC_IsEXIT) (MkErrorC_ARGS) {
577 end: MK_UNUSED /* LONG JUMP on error */
579}
580
582static OT_ProcRet NS(MkErrorC_IsSOCKET) (MkErrorC_ARGS) {
587 end: MK_UNUSED /* LONG JUMP on error */
589}
590
592static OT_ProcRet NS(MkErrorC_IsTIMEOUT) (MkErrorC_ARGS) {
597 end: MK_UNUSED /* LONG JUMP on error */
599}
600
602static OT_ProcRet NS(MkErrorC_SetABORT) (MkErrorC_ARGS) {
605 MK_STRN detail = "UNKNOWN";
607 MK_STRN callfunc = NULL;
610 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
611 MkErrorC_Check(hdl,MkErrorSetABORT (hdl, detail, callfunc));
613 end: MK_UNUSED /* LONG JUMP on error */
616}
617
619static OT_ProcRet NS(MkErrorC_SetCONTINUE) (MkErrorC_ARGS) {
623 MkErrorSetCONTINUE (hdl);
625 end: MK_UNUSED /* LONG JUMP on error */
627}
628
630static OT_ProcRet NS(MkErrorC_SetCode) (MkErrorC_ARGS) {
633 enum MkErrorE code = 0;
636 MkErrorSetCode (hdl, code);
638 end: MK_UNUSED /* LONG JUMP on error */
640}
641
643static OT_ProcRet NS(MkErrorC_SetEXIT) (MkErrorC_ARGS) {
646 MK_STRN callfunc = NULL;
649 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
650 MkErrorC_Check(hdl,MkErrorSetEXIT (hdl, callfunc));
652 end: MK_UNUSED /* LONG JUMP on error */
655}
656
658static OT_ProcRet NS(MkErrorC_SetSOCKET) (MkErrorC_ARGS) {
661 MK_STRN detail = "UNKNOWN";
663 MK_STRN callfunc = NULL;
666 if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
667 MkErrorC_Check(hdl,MkErrorSetSOCKET (hdl, detail, callfunc));
669 end: MK_UNUSED /* LONG JUMP on error */
672}
673
675// MkErrorC_Signal_RB_API
676
680
681// doc-key: MkErrorC,MkErrorC-System,sc_
682
684static OT_ProcRet NS(MkErrorC_DEFAULT) (OtClass_ARGS) {
688 MK_ERR retVal = MkErrorDEFAULT ();
689 OT_retObj_SET_ERR(retVal);
690 end: MK_UNUSED /* LONG JUMP on error */
692}
693
695static OT_ProcRet NS(MkErrorC_FORMAT) (OtClass_ARGS) {
698 MK_OBJN fmtobj = NULL;
701 MK_ERR retVal = MkErrorFORMAT (fmtobj);
702 OT_retObj_SET_ERR(retVal);
703 end: MK_UNUSED /* LONG JUMP on error */
705}
706
708static OT_ProcRet NS(MkErrorC_IGNORE) (OtClass_ARGS) {
712 MK_ERR retVal = MkErrorIGNORE ();
713 OT_retObj_SET_ERR(retVal);
714 end: MK_UNUSED /* LONG JUMP on error */
716}
717
719static OT_ProcRet NS(MkErrorC_PRINT) (OtClass_ARGS) {
723 MK_ERR retVal = MkErrorPRINT ();
724 OT_retObj_SET_ERR(retVal);
725 end: MK_UNUSED /* LONG JUMP on error */
727}
728
730// MkErrorC_System_RB_API
731
735
736// doc-key: MkErrorC,MkErrorC-TOR,oCx
737
739static OT_ProcRet NS(MkErrorC_Dup) (MkErrorC_ARGS) {
743 MK_ERR retVal = MkErrorDup (hdl);
744 if (retVal == NULL) {
745 OT_ERROR_CONSTRUCTOR(MkErrorC);
746 }
747 OT_retObj_SET_ERR(retVal);
748 end: MK_UNUSED /* LONG JUMP on error */
750}
751
752// doc-key: MkErrorC,MkErrorC-TOR,om_
753
755static OT_ProcRet NS(MkErrorC_Copy) (MkErrorC_ARGS) {
758 MK_ERRN srce = 0;
761 MkErrorCopy (hdl, srce);
763 end: MK_UNUSED /* LONG JUMP on error */
765}
766
768// MkErrorC_TOR_RB_API
769
770// END-MkErrorC - created by 'rb_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
771
772/*****************************************************************************/
773/* */
774/* public */
775/* */
776/*****************************************************************************/
777
778static void NS(sMark) (MK_PTR mng) {
779}
780
781void MK(MkErrorC_Init) (MK_RT_ARGS_ONLY) {
782
783 // init type
785 S_INIT;
786
787// CON/DE-Structor for default ERROR objects
788 MkErrorDefaultC_TT->selfCreate = MK(MkErrorC_selfCreate);
789 MkErrorDefaultC_TT->selfDelete = MK(MkErrorC_selfDelete);
790 MkErrorDefaultC_TT->selfUnlink = MK(MkErrorC_selfUnlink);
791
792// BEGIN-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
793
794// doc-key: MkErrorC,MkError,sc_
795OT_METH_O ( MkErrorC, DEFAULT, MkErrorC_DEFAULT )
796OT_METH_S ( MkErrorC, DEFAULT, MkErrorC_DEFAULT )
797OT_METH_O ( MkErrorC, FORMAT, MkErrorC_FORMAT )
798OT_METH_S ( MkErrorC, FORMAT, MkErrorC_FORMAT )
799OT_METH_O ( MkErrorC, GetNull, MkErrorC_GetNull )
800OT_METH_S ( MkErrorC, GetNull, MkErrorC_GetNull )
801OT_METH_O ( MkErrorC, HandleResolve, MkErrorC_HandleResolve )
802OT_METH_S ( MkErrorC, HandleResolve, MkErrorC_HandleResolve )
803OT_METH_O ( MkErrorC, IGNORE, MkErrorC_IGNORE )
804OT_METH_S ( MkErrorC, IGNORE, MkErrorC_IGNORE )
805OT_METH_O ( MkErrorC, Instances, MkErrorC_Instances )
806OT_METH_S ( MkErrorC, Instances, MkErrorC_Instances )
807OT_METH_O ( MkErrorC, PRINT, MkErrorC_PRINT )
808OT_METH_S ( MkErrorC, PRINT, MkErrorC_PRINT )
809
810// doc-key: MkErrorC,MkPanic,sm_
811OT_METH_O ( MkErrorC, PanicC, MkErrorC_PanicC )
812OT_METH_S ( MkErrorC, PanicC, MkErrorC_PanicC )
813OT_METH_O ( MkErrorC, PanicDEFAULT, MkErrorC_PanicDEFAULT )
814OT_METH_S ( MkErrorC, PanicDEFAULT, MkErrorC_PanicDEFAULT )
815
816// END-CLASS - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
817
818// BEGIN-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
819
820// doc-key: MkErrorC,MkError,oCx
821OT_METH_O ( MkErrorC, Dup, MkErrorC_Dup )
822
823// doc-key: MkErrorC,MkError,oc_
824OT_METH_O ( MkErrorC, Catch, MkErrorC_Catch )
825OT_METH_O ( MkErrorC, Next, MkErrorC_Next )
826OT_METH_O ( MkErrorC, NoRaise, MkErrorC_NoRaise )
827OT_METH_O ( MkErrorC, Prev, MkErrorC_Prev )
828
829// doc-key: MkErrorC,MkError,om_
830OT_METH_O ( MkErrorC, AppendC, MkErrorC_AppendC )
831OT_METH_O ( MkErrorC, Cleanup, MkErrorC_Cleanup )
832OT_METH_O ( MkErrorC, Copy, MkErrorC_Copy )
833OT_METH_O ( MkErrorC, GetCode, MkErrorC_GetCode )
834OT_METH_O ( MkErrorC, GetNum, MkErrorC_GetNum )
835OT_METH_O ( MkErrorC, GetSize, MkErrorC_GetSize )
836OT_METH_O ( MkErrorC, GetText, MkErrorC_GetText )
837// skip class-overload: MkErrorHandleGet → HandleGet, MkErrorC_HandleGet
838OT_METH_O ( MkErrorC, IsABORT, MkErrorC_IsABORT )
839OT_METH_O ( MkErrorC, IsEXIT, MkErrorC_IsEXIT )
840OT_METH_O ( MkErrorC, IsSOCKET, MkErrorC_IsSOCKET )
841OT_METH_O ( MkErrorC, IsTIMEOUT, MkErrorC_IsTIMEOUT )
842// skip class-overload: MkErrorLog → Log, MkErrorC_Log
843OT_METH_O ( MkErrorC, Println, MkErrorC_Println )
844OT_METH_O ( MkErrorC, Raise, MkErrorC_Raise )
845OT_METH_O ( MkErrorC, Reset, MkErrorC_Reset )
846OT_METH_O ( MkErrorC, SetABORT, MkErrorC_SetABORT )
847OT_METH_O ( MkErrorC, SetC, MkErrorC_SetC )
848OT_METH_O ( MkErrorC, SetCONTINUE, MkErrorC_SetCONTINUE )
849OT_METH_O ( MkErrorC, SetCode, MkErrorC_SetCode )
850OT_METH_O ( MkErrorC, SetEXIT, MkErrorC_SetEXIT )
851OT_METH_O ( MkErrorC, SetSOCKET, MkErrorC_SetSOCKET )
852OT_METH_O ( MkErrorC, Stack, MkErrorC_Stack )
853OT_METH_O ( MkErrorC, StackFormat, MkErrorC_StackFormat )
854// skip class-overload: MkErrorToString → ToString, MkErrorC_ToString
855
856// END-OBJ - created by 'rb_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
857
858}
tag: nhi1-release-250425
#define OT_CHECK_bool(val)
#define MK(n)
#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_NEW_Mk_enum_OBJ(typ, i)
#define OT_ERROR_LNG_RETURN
#define PTR2VAL(nat)
#define OT_CHECK_NI4(val)
#define OT_PKG
#define OT_GET_CALL_LINE
#define OT_METH_S(c, s, f)
#define MK_BASE_CLASS
#define OT_CLS_T
#define OT_FRAME_CLEANUP
#define OT_retObj_SET_LONG(nat)
#define OT_CHECK_REQUIRED(val)
#define OT_retObj_SET_None
#define OT_retObj_SET_I32(nat)
#define OT_METH_O(c, s, f)
#define OT_GET_CALL_FILE
#define INCR_REF(valP)
#define OT_OBJ_T
#define NS(n)
#define OT_retObj_RETURN
#define MkErrorC_MK_NULL
#define OT_GET_CALL_PROC
#define OT_OBJECT_DELETE_HARD(obj)
#define OT_retObj_SET_STR(nat)
#define OT_ERROR_CONSTRUCTOR(clazz)
#define OT_CHECK_OPTIONAL(val)
#define OT_retObj_SET_ERR(nat)
#define MkErrorC_ARGS
#define OT_retObj_SET(val)
#define VAL2PTR(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_rb.c:87
#define SetEXIT_doc
static MK_TYP MkErrorCTT
Definition MkErrorC_rb.c:22
#define NoRaise_doc
#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_rb.c:14
#define Println_doc
#define OT_SETUP_hdl_static
Definition MkErrorC_rb.c:93
#define MkErrorCatchTmpl(...)
#define IsEXIT_doc
#define GetNum_doc
#define IGNORE_doc
#define IsTIMEOUT_doc
#define OT_SETUP_hdl__null_allow
Definition MkErrorC_rb.c:88
#define FORMAT_doc
#define Cleanup_doc
#define SetCONTINUE_doc
#define PanicC_doc
#define S_INIT
Definition MkErrorC_rb.c:69
#define PRINT_doc
#define AppendC_doc
#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_T
class as MkTypeDefS-class-type, useable in a class-macro as: class##_T …
#define MkErrorC_TT
class as MkTypeS-class-type, useable in a class-macro as: class##_TT …
#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_NULL
The Programming-Language-Micro-Kernel (PLMK) NULL value as nil in Ruby …
#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 * MK_MNG
managed object pointer, datatype will be checked at runtime
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_ARGS
#define MK_RT_ARGS_ONLY
#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 …
object header …
MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type...
MkSelfUnlinkF selfUnlink
"unlink" the "self" pointer from META-Kernel
MkSelfDeleteF selfDelete
"delete" the "self" pointer
MkSelfCreateF selfCreate
"create" the "self" pointer