theKernel 10.0
Loading...
Searching...
No Matches
MkErrorC_jv.c
Go to the documentation of this file.
1
9/* LABEL-START */
10#define META_FILE_NAME "MkErrorC_jv.c"
11
12#include "jni_h/jvmkkernel_MkErrorC.h"
13#include "LibMkKernel_private_jv.h"
14
15
16jobject NS(MkErrorC_ObjNew) (MK_RT_ARGS JNIEnv *env, MK_ERR hdl) {
17 static MkThreadLocal jobject NS_NULL = NULL;
18 return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MkErrorC_X2obj(hdl)) : MK_GET__NS_NULL(MkErrorC));
19}
20
21MK_UNUSED
22static jobject NS(MkErrorC_ObjCreate) (MK_RT_ARGS JNIEnv *env, MK_ERR hdl) {
23 return MK(AtomObjCreate)(MK_RT_CALL env, MkErrorC_X2obj(hdl));
24}
25
26static MK_PTR NS(MkErrorC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
27 JNIEnv *env = (JNIEnv*) envP;
28 return (*env)->NewObject(env, NS(Class_MkErrorC), NS(MID_MkErrorC_INIT), (jlong) obj, JNI_TRUE);
29}
30
31#define ClassInit \
32
33// printTxt("init: MkErrorC");
34
35/* LABEL-END */
36
37#define MkErrorCatchTmpl(...) NS(MkExceptionC_Catch) (env,__VA_ARGS__, NULL)
38
39// BEGIN-MkErrorC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
40
44
45// doc-key: MkErrorC,MkErrorC-Class-Export,sc_
46
48JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_HandleResolve (JNIEnv *env, jclass class, jint netHdl) {
49 MkRtSetup_NULL;
50 MK_ERR __retVal__L = MkErrorHandleResolve(netHdl);
51 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
52 return __retVal__S;
53}
54
55// doc-key: MkErrorC,MkErrorC-Class-Export,om_
56
57// skip class-overload: HandleGet = MkErrorHandleGet → MkObjectHandleGet
58
60// MkErrorC_Class_JV_API
61
65
66// doc-key: MkErrorC,MkErrorC-Class-Introspection,oc_
67
69JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Next (JNIEnv *env, jobject self) {
70 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
71 JavaErrorCheck;
72 MkRtSetup_X(hdl);
73 MK_ERR __retVal__L = MkErrorNext(hdl);
74 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
75 return __retVal__S;
76error:
77 return 0;
78}
79
81JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Prev (JNIEnv *env, jobject self) {
82 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
83 JavaErrorCheck;
84 MkRtSetup_X(hdl);
85 MK_ERR __retVal__L = MkErrorPrev(hdl);
86 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
87 return __retVal__S;
88error:
89 return 0;
90}
91
92// doc-key: MkErrorC,MkErrorC-Class-Introspection,sc_
93
95JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Instances (JNIEnv *env, jclass class) {
96 MkRtSetup_NULL;
97 MK_ERR __retVal__L = MkErrorInstances();
98 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
99 return __retVal__S;
100}
101
103// MkErrorC_Class_JV_API
104
108
109// doc-key: MkErrorC,MkErrorC-Class-Misc,sc_
110
112JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_GetNull (JNIEnv *env, jclass class) {
113 MkRtSetup_NULL;
114 MK_ERR __retVal__L = MkErrorGetNull();
115 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
116 return __retVal__S;
117}
118
120// MkErrorC_Class_JV_API
121
125
126// doc-key: MkErrorC,MkErrorC-Get,om_
127
129JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_GetCode (JNIEnv *env, jobject self) {
130 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
131 JavaErrorCheck;
132 MkRtSetup_X(hdl);
133 enum MkErrorE errVal = MkErrorGetCodeI(hdl);
134 jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkErrorE),"Ljvmkkernel/MkErrorE;",MkErrorE_ToString(errVal));
135 return __retVal__S;
136error:
137 return 0;
138}
139
141JNIEXPORT jint JNICALL Java_jvmkkernel_MkErrorC_GetNum (JNIEnv *env, jobject self) {
142 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
143 JavaErrorCheck;
144 MkRtSetup_X(hdl);
145 MK_I32 __retVal__L = MkErrorGetNumI(hdl);
146 jint __retVal__S = __retVal__L;
147 return __retVal__S;
148error:
149 return 0;
150}
151
153JNIEXPORT jlong JNICALL Java_jvmkkernel_MkErrorC_GetSize (JNIEnv *env, jobject self) {
154 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
155 JavaErrorCheck;
156 MkRtSetup_X(hdl);
157 MK_SIZE __retVal__L = MkErrorGetSizeI(hdl);
158 jlong __retVal__S = __retVal__L;
159 return __retVal__S;
160error:
161 return 0;
162}
163
165JNIEXPORT jstring JNICALL Java_jvmkkernel_MkErrorC_GetText (JNIEnv *env, jobject self) {
166 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
167 JavaErrorCheck;
168 MkRtSetup_X(hdl);
169 MK_STRN __retVal__L = MkErrorGetTextI(hdl);
170 jstring __retVal__S = JC2O(env,__retVal__L);
171 return __retVal__S;
172error:
173 return 0;
174}
175
177// MkErrorC_Get_JV_API
178
182
183// doc-key: MkErrorC,MkErrorC-Misc,oc_
184
186JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Catch (JNIEnv *env, jobject self, jthrowable exception, jstring callfunc) {
187 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
188 JavaErrorCheck;
189 MkRtSetup_X(hdl);
190 if (callfunc == NULL) {
191 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
192 }
193 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
194 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
195 JavaErrorCheck;
196 MK_ERR __retVal__L = MkErrorCatchTmpl(hdl, exception, callfunc_ptr);
197 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
198 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
199 return __retVal__S;
200error:
201 return 0;
202}
203
204// doc-key: MkErrorC,MkErrorC-Misc,om_
205
207JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Cleanup (JNIEnv *env, jobject self, jstring callfunc, jint callline) {
208 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
209 JavaErrorCheck;
210 MkRtSetup_X(hdl);
211 if (callline == -1 && callfunc == NULL) {
212 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
213 }
214 if (callline == -1) {callline = MK(pGetCallerLine)(env);}
215 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
216 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
217 JavaErrorCheck;
218 MkErrorCleanup(hdl, callfunc_ptr, callline);
219 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
220error:
221 return;
222}
223
224// skip class-overload: Log = MkErrorLog → MkObjectLog
225
227JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Println (JNIEnv *env, jobject self, jstring msg, jstring callfunc, jint callline) {
228 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
229 JavaErrorCheck;
230 MkRtSetup_X(hdl);
231 if (callline == -1 && callfunc == NULL) {
232 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
233 }
234 if (callline == -1) {callline = MK(pGetCallerLine)(env);}
235 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
236 MK_STRN msg_ptr = (msg?(*env)->GetStringUTFChars(env,msg,NULL):NULL);
237 JavaErrorCheck;
238 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
239 JavaErrorCheck;
240 MkErrorPrintln(hdl, msg_ptr, callfunc_ptr, callline);
241 if (msg_ptr) (*env)->ReleaseStringUTFChars(env,msg,msg_ptr);
242 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
243error:
244 return;
245}
246
248JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Reset (JNIEnv *env, jobject self, jstring callfunc, jint callline, jboolean force) {
249 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
250 JavaErrorCheck;
251 MkRtSetup_X(hdl);
252 if (callline == -1 && callfunc == NULL) {
253 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
254 }
255 if (callline == -1) {callline = MK(pGetCallerLine)(env);}
256 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
257 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
258 JavaErrorCheck;
259 enum MkErrorE errVal = MkErrorReset(hdl, callfunc_ptr, callline, force);
260 MkErrorC_Check(hdl, errVal)
261 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
262error:
263 return;
264}
265
267JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Stack (JNIEnv *env, jobject self, jstring callfunc, jstring callfile, jint callline) {
268 MK_ERR hdl = (MK_ERR)pObj2Hdl__null_allow(env,self);
269 JavaErrorCheck;
270 MkRtSetup_X(hdl);
271 if (callline == -1 && callfile == NULL && callfunc == NULL) {
272 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
273 }
274 if (callline == -1) {callline = MK(pGetCallerLine)(env);}
275 if (callfile == NULL) {callfile = MK(pGetCallerFile)(env);}
276 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
277 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
278 JavaErrorCheck;
279 MK_STRN callfile_ptr = (callfile?(*env)->GetStringUTFChars(env,callfile,NULL):NULL);
280 JavaErrorCheck;
281 enum MkErrorE errVal = MkErrorStack(hdl, callfunc_ptr, callfile_ptr, callline);
282 jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkErrorE),"Ljvmkkernel/MkErrorE;",MkErrorE_ToString(errVal));
283 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
284 if (callfile_ptr) (*env)->ReleaseStringUTFChars(env,callfile,callfile_ptr);
285 return __retVal__S;
286error:
287 return 0;
288}
289
291JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_StackFormat (JNIEnv *env, jobject self, jstring callfunc, jstring callfile, jint callline) {
292 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
293 JavaErrorCheck;
294 MkRtSetup_X(hdl);
295 if (callline == -1 && callfile == NULL && callfunc == NULL) {
296 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
297 }
298 if (callline == -1) {callline = MK(pGetCallerLine)(env);}
299 if (callfile == NULL) {callfile = MK(pGetCallerFile)(env);}
300 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
301 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
302 JavaErrorCheck;
303 MK_STRN callfile_ptr = (callfile?(*env)->GetStringUTFChars(env,callfile,NULL):NULL);
304 JavaErrorCheck;
305 MkErrorStackFormat(hdl, callfunc_ptr, callfile_ptr, callline);
306 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
307 if (callfile_ptr) (*env)->ReleaseStringUTFChars(env,callfile,callfile_ptr);
308error:
309 return;
310}
311
312// skip class-overload: ToString = MkErrorToString → MkObjectToString
313
315// MkErrorC_Misc_JV_API
316
320
321// doc-key: MkErrorC,MkErrorC-Raise,oc_
322
324JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_NoRaise (JNIEnv *env, jobject self) {
325 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
326 JavaErrorCheck;
327 MkRtSetup_X(hdl);
328 MK_ERR __retVal__L = MkErrorNoRaise(hdl);
329 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
330 return __retVal__S;
331error:
332 return 0;
333}
334
335// doc-key: MkErrorC,MkErrorC-Raise,om_
336
338JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_AppendC (JNIEnv *env, jobject self, jstring message) {
339 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
340 JavaErrorCheck;
341 MkRtSetup_X(hdl);
342 MK_STRN message_ptr = (message?(*env)->GetStringUTFChars(env,message,NULL):NULL);
343 JavaErrorCheck;
344 MkErrorAppendC(hdl, message_ptr);
345 if (message_ptr) (*env)->ReleaseStringUTFChars(env,message,message_ptr);
346error:
347 return;
348}
349
351JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Raise (JNIEnv *env, jobject self) {
352 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
353 JavaErrorCheck;
354 MkRtSetup_X(hdl);
355 enum MkErrorE errVal = MkErrorRaise(hdl);
356 MkErrorC_Check(hdl, errVal)
357error:
358 return;
359}
360
362JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetC (JNIEnv *env, jobject self, jstring message, jstring callfunc, jint errnum) {
363 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
364 JavaErrorCheck;
365 MkRtSetup_X(hdl);
366 if (callfunc == NULL) {
367 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
368 }
369 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
370 MK_STRN message_ptr = (message?(*env)->GetStringUTFChars(env,message,NULL):NULL);
371 JavaErrorCheck;
372 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
373 JavaErrorCheck;
374 enum MkErrorE errVal = MkErrorSetC(hdl, message_ptr, callfunc_ptr, errnum);
375 MkErrorC_Check(hdl, errVal)
376 if (message_ptr) (*env)->ReleaseStringUTFChars(env,message,message_ptr);
377 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
378error:
379 return;
380}
381
382// doc-key: MkErrorC,MkErrorC-Raise,sm_
383
385JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_PanicC (JNIEnv *env, jclass class, jobject fmtobj, jstring callfunc, jint errnum, jstring message) {
386 MkRtSetup_NULL;
387 MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
388 JavaErrorCheck;
389 if (callfunc == NULL) {
390 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
391 }
392 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
393 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
394 JavaErrorCheck;
395 MK_STRN message_ptr = (message?(*env)->GetStringUTFChars(env,message,NULL):NULL);
396 JavaErrorCheck;
397 MkPanicC(fmtobj_hdl, callfunc_ptr, errnum, message_ptr);
398 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
399 if (message_ptr) (*env)->ReleaseStringUTFChars(env,message,message_ptr);
400error:
401 return;
402}
403
405JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_PanicDEFAULT (JNIEnv *env, jclass class, jobject fmtobj, jstring callfunc) {
406 MkRtSetup_NULL;
407 MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
408 JavaErrorCheck;
409 if (callfunc == NULL) {
410 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
411 }
412 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
413 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
414 JavaErrorCheck;
415 MkPanicDEFAULT(fmtobj_hdl, callfunc_ptr);
416 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
417error:
418 return;
419}
420
422// MkErrorC_Raise_JV_API
423
427
428// doc-key: MkErrorC,MkErrorC-Signal,om_
429
431JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsABORT (JNIEnv *env, jobject self) {
432 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
433 JavaErrorCheck;
434 MkRtSetup_X(hdl);
435 MK_BOOL __retVal__L = MkErrorIsABORT(hdl);
436 jboolean __retVal__S = __retVal__L;
437 return __retVal__S;
438error:
439 return 0;
440}
441
443JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsEXIT (JNIEnv *env, jobject self) {
444 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
445 JavaErrorCheck;
446 MkRtSetup_X(hdl);
447 MK_BOOL __retVal__L = MkErrorIsEXIT(hdl);
448 jboolean __retVal__S = __retVal__L;
449 return __retVal__S;
450error:
451 return 0;
452}
453
455JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsSOCKET (JNIEnv *env, jobject self) {
456 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
457 JavaErrorCheck;
458 MkRtSetup_X(hdl);
459 MK_BOOL __retVal__L = MkErrorIsSOCKET(hdl);
460 jboolean __retVal__S = __retVal__L;
461 return __retVal__S;
462error:
463 return 0;
464}
465
467JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsTIMEOUT (JNIEnv *env, jobject self) {
468 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
469 JavaErrorCheck;
470 MkRtSetup_X(hdl);
471 MK_BOOL __retVal__L = MkErrorIsTIMEOUT(hdl);
472 jboolean __retVal__S = __retVal__L;
473 return __retVal__S;
474error:
475 return 0;
476}
477
479JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetABORT (JNIEnv *env, jobject self, jstring detail, jstring callfunc) {
480 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
481 JavaErrorCheck;
482 MkRtSetup_X(hdl);
483 if (callfunc == NULL) {
484 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
485 }
486 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
487 MK_STRN detail_ptr = (detail?(*env)->GetStringUTFChars(env,detail,NULL):NULL);
488 JavaErrorCheck;
489 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
490 JavaErrorCheck;
491 enum MkErrorE errVal = MkErrorSetABORT(hdl, detail_ptr, callfunc_ptr);
492 MkErrorC_Check(hdl, errVal)
493 if (detail_ptr) (*env)->ReleaseStringUTFChars(env,detail,detail_ptr);
494 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
495error:
496 return;
497}
498
500JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetCONTINUE (JNIEnv *env, jobject self) {
501 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
502 JavaErrorCheck;
503 MkRtSetup_X(hdl);
504 MkErrorSetCONTINUE(hdl);
505error:
506 return;
507}
508
510JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetCode (JNIEnv *env, jobject self, jobject code) {
511 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
512 JavaErrorCheck;
513 MkRtSetup_X(hdl);
514 enum MkErrorE code_e = MK(pGetEnumFromObj)(env, NS(Class_MkErrorE), code);
515 JavaErrorCheck;
516 MkErrorSetCode(hdl, code_e);
517error:
518 return;
519}
520
522JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetEXIT (JNIEnv *env, jobject self, jstring callfunc) {
523 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
524 JavaErrorCheck;
525 MkRtSetup_X(hdl);
526 if (callfunc == NULL) {
527 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
528 }
529 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
530 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
531 JavaErrorCheck;
532 enum MkErrorE errVal = MkErrorSetEXIT(hdl, callfunc_ptr);
533 MkErrorC_Check(hdl, errVal)
534 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
535error:
536 return;
537}
538
540JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetSOCKET (JNIEnv *env, jobject self, jstring detail, jstring callfunc) {
541 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
542 JavaErrorCheck;
543 MkRtSetup_X(hdl);
544 if (callfunc == NULL) {
545 (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
546 }
547 if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
548 MK_STRN detail_ptr = (detail?(*env)->GetStringUTFChars(env,detail,NULL):NULL);
549 JavaErrorCheck;
550 MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
551 JavaErrorCheck;
552 enum MkErrorE errVal = MkErrorSetSOCKET(hdl, detail_ptr, callfunc_ptr);
553 MkErrorC_Check(hdl, errVal)
554 if (detail_ptr) (*env)->ReleaseStringUTFChars(env,detail,detail_ptr);
555 if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
556error:
557 return;
558}
559
561// MkErrorC_Signal_JV_API
562
566
567// doc-key: MkErrorC,MkErrorC-System,sc_
568
570JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_DEFAULT (JNIEnv *env, jclass class) {
571 MkRtSetup_NULL;
572 MK_ERR __retVal__L = MkErrorDEFAULT();
573 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
574 return __retVal__S;
575}
576
578JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_FORMAT (JNIEnv *env, jclass class, jobject fmtobj) {
579 MkRtSetup_NULL;
580 MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
581 JavaErrorCheck;
582 MK_ERR __retVal__L = MkErrorFORMAT(fmtobj_hdl);
583 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
584 return __retVal__S;
585error:
586 return 0;
587}
588
590JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_IGNORE (JNIEnv *env, jclass class) {
591 MkRtSetup_NULL;
592 MK_ERR __retVal__L = MkErrorIGNORE();
593 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
594 return __retVal__S;
595}
596
598JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_PRINT (JNIEnv *env, jclass class) {
599 MkRtSetup_NULL;
600 MK_ERR __retVal__L = MkErrorPRINT();
601 jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
602 return __retVal__S;
603}
604
606// MkErrorC_System_JV_API
607
611
612// doc-key: MkErrorC,MkErrorC-TOR,oCx
613
615JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Dup (JNIEnv *env, jobject self) {
616 MK_ERRN hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",self);
617 JavaErrorCheck;
618 MkRtSetup_X(hdl);
619 MK_ERR __retVal__L = MkErrorDup(hdl);
620 if (__retVal__L == NULL) {
621 (*env)->ThrowNew(env, MK(Class_MkInitError), "MkErrorC.Dup");
622 goto error;
623 }
624 jobject __retVal__S = MK(MkErrorC_ObjCreate)(MK_RT_CALL env,__retVal__L);
625 return __retVal__S;
626error:
627 return 0;
628}
629
630// doc-key: MkErrorC,MkErrorC-TOR,om_
631
633JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Copy (JNIEnv *env, jobject self, jobject srce) {
634 MK_ERR hdl = (MK_ERR)pObj2Hdl(env,"MkErrorC",self);
635 JavaErrorCheck;
636 MkRtSetup_X(hdl);
637 MK_ERRN srce_hdl = (MK_ERRN)pObj2Hdl(env,"MkErrorC",srce);
638 JavaErrorCheck;
639 MkErrorCopy(hdl, srce_hdl);
640error:
641 return;
642}
643
645// MkErrorC_TOR_JV_API
646
647// END-MkErrorC - created by 'jv_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
648
649// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
650
651void NS(MkErrorC_Init)(MK_RT_ARGS_ONLY) {
652 ClassInit
653
654 MkErrorC_TT->selfCreate = NS(MkErrorC_selfCreate) ;
655 MkErrorC_TT->selfUnlink = MK(AtomSelfUnlink) ;
656
657 MkErrorDefaultC_TT->selfCreate = NS(MkErrorC_selfCreate) ;
658 MkErrorDefaultC_TT->selfUnlink = MK(AtomSelfUnlink) ;
659}
MkErrorCatchTmpl
#define MkErrorCatchTmpl(...)
Definition MkErrorC_jv.c:37
ClassInit
#define ClassInit
Definition MkErrorC_jv.c:31
MkErrorNext
static MK_ERR MkErrorNext(MK_ERR const err)
get next instance from linked-list of MkErrorS type
Definition LibMkKernel_mk.h:13294
MkErrorHandleResolve
#define MkErrorHandleResolve(...)
Definition kernel_overload_mk.h:948
MkErrorGetNull
static MK_ERR MkErrorGetNull(void)
Null-Slot - return a MkErrorC typed NULL instance …
Definition LibMkKernel_mk.h:9945
MkErrorPrev
static MK_ERR MkErrorPrev(MK_ERR const err)
get previous instance from linked-list of MkErrorS type
Definition LibMkKernel_mk.h:13301
MkErrorInstances
#define MkErrorInstances()
Definition kernel_overload_mk.h:971
MK_ERRN
const struct MkErrorS * MK_ERRN
class-shortcut for const struct MkErrorS *, all const shortcut using the XX_YYYC syntax (only for pub...
Definition LibMkKernel_mk.h:1579
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
MkErrorC_X2obj
#define MkErrorC_X2obj(x)
Definition LibMkKernel_mk.h:9753
MkErrorC_TT
#define MkErrorC_TT
class as MkTypeS-class-type, useable in a class-macro as: class##_TT …
Definition LibMkKernel_mk.h:9768
Java_jvmkkernel_MkErrorC_Instances
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Instances(JNIEnv *env, jclass class)
Java: [static] MkErrorC MkErrorC.Instances() → C-API get head-instance from linked-list of MkErr...
Definition MkErrorC_jv.c:95
Java_jvmkkernel_MkErrorC_Next
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Next(JNIEnv *env, jobject self)
Java: MkErrorC err.Next() → C-API get next instance from linked-list of MkErrorS type
Definition MkErrorC_jv.c:69
Java_jvmkkernel_MkErrorC_GetNull
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_GetNull(JNIEnv *env, jclass class)
Java: [static] MkErrorC MkErrorC.GetNull() → C-API Null-Slot - return a MkErrorC typed NULL inst...
Definition MkErrorC_jv.c:112
Java_jvmkkernel_MkErrorC_HandleResolve
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_HandleResolve(JNIEnv *env, jclass class, jint netHdl)
Java: [static] MkErrorC MkErrorC.HandleResolve(int netHdl) → C-API Handle-Resolve-Slot - return ...
Definition MkErrorC_jv.c:48
Java_jvmkkernel_MkErrorC_Prev
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Prev(JNIEnv *env, jobject self)
Java: MkErrorC err.Prev() → C-API get previous instance from linked-list of MkErrorS type
Definition MkErrorC_jv.c:81
MkErrorGetSizeI
#define MkErrorGetSizeI(e)
get the error-message-size from the exception-object …
Definition LibMkKernel_mk.h:10933
MkErrorGetCodeI
#define MkErrorGetCodeI(e)
get the value of MkErrorS::code …
Definition LibMkKernel_mk.h:10911
MkErrorGetTextI
#define MkErrorGetTextI(e)
get the MkErrorS::text …
Definition LibMkKernel_mk.h:10924
MkErrorGetNumI
#define MkErrorGetNumI(e)
get the MkErrorS::num. The number can be used as exit-code …
Definition LibMkKernel_mk.h:10942
Java_jvmkkernel_MkErrorC_GetSize
JNIEXPORT jlong JNICALL Java_jvmkkernel_MkErrorC_GetSize(JNIEnv *env, jobject self)
Java: long err.GetSize() → C-API get the error-message-size from the exception-object …
Definition MkErrorC_jv.c:153
Java_jvmkkernel_MkErrorC_GetText
JNIEXPORT jstring JNICALL Java_jvmkkernel_MkErrorC_GetText(JNIEnv *env, jobject self)
Java: String err.GetText() → C-API get the MkErrorS::text …
Definition MkErrorC_jv.c:165
Java_jvmkkernel_MkErrorC_GetNum
JNIEXPORT jint JNICALL Java_jvmkkernel_MkErrorC_GetNum(JNIEnv *env, jobject self)
Java: int err.GetNum() → C-API get the MkErrorS::num. The number can be used as exit-code …
Definition MkErrorC_jv.c:141
Java_jvmkkernel_MkErrorC_GetCode
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_GetCode(JNIEnv *env, jobject self)
Java: MkErrorE err.GetCode() → C-API get the value of MkErrorS::code …
Definition MkErrorC_jv.c:129
MkErrorStackFormat
#define MkErrorStackFormat(...)
Definition kernel_overload_mk.h:1083
MkErrorPrintln
#define MkErrorPrintln(...)
Definition kernel_overload_mk.h:1039
MkErrorCleanup
#define MkErrorCleanup(...)
Definition kernel_overload_mk.h:1013
MkErrorStack
#define MkErrorStack(...)
Definition kernel_overload_mk.h:1067
MkErrorReset
#define MkErrorReset(...)
Definition kernel_overload_mk.h:1052
Java_jvmkkernel_MkErrorC_Println
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Println(JNIEnv *env, jobject self, jstring msg, jstring callfunc, jint callline)
Java: err.Println(?String msg = ""?, ?String callfunc = null?, ?int callline = -1?...
Definition MkErrorC_jv.c:227
Java_jvmkkernel_MkErrorC_Reset
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Reset(JNIEnv *env, jobject self, jstring callfunc, jint callline, jboolean force)
Java: err.Reset(?String callfunc = null?, ?int callline = -1?, ?boolean force = false?...
Definition MkErrorC_jv.c:248
Java_jvmkkernel_MkErrorC_Cleanup
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Cleanup(JNIEnv *env, jobject self, jstring callfunc, jint callline)
Java: err.Cleanup(?String callfunc = null?, ?int callline = -1?) → C-API cleanup and print unwa...
Definition MkErrorC_jv.c:207
Java_jvmkkernel_MkErrorC_Stack
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Stack(JNIEnv *env, jobject self, jstring callfunc, jstring callfile, jint callline)
Java: MkErrorE err.Stack(?String callfunc = null?, ?String callfile = null?, ?int callline = -1?...
Definition MkErrorC_jv.c:267
Java_jvmkkernel_MkErrorC_Catch
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Catch(JNIEnv *env, jobject self, jthrowable exception, jstring callfunc)
Java: MkErrorC err.Catch(?Throwable exception = null?, ?String callfunc = null?) → C-API conver...
Definition MkErrorC_jv.c:186
Java_jvmkkernel_MkErrorC_StackFormat
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_StackFormat(JNIEnv *env, jobject self, jstring callfunc, jstring callfile, jint callline)
Java: err.StackFormat(?String callfunc = null?, ?String callfile = null?, ?int callline = -1?...
Definition MkErrorC_jv.c:291
MkErrorSetC
#define MkErrorSetC(...)
Definition kernel_overload_mk.h:1133
MkPanicDEFAULT
#define MkPanicDEFAULT(...)
Definition kernel_overload_mk.h:1197
MkErrorRaise
#define MkErrorRaise(...)
Definition kernel_overload_mk.h:1127
MkPanicC
#define MkPanicC(...)
Definition kernel_overload_mk.h:1192
MkErrorAppendC
#define MkErrorAppendC(...)
Definition kernel_overload_mk.h:1115
MkErrorNoRaise
#define MkErrorNoRaise(...)
Definition kernel_overload_mk.h:1109
Java_jvmkkernel_MkErrorC_NoRaise
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_NoRaise(JNIEnv *env, jobject self)
Java: MkErrorC err.NoRaise() → C-API ignore the next return of MK_ERROR and do not raise an tar...
Definition MkErrorC_jv.c:324
Java_jvmkkernel_MkErrorC_PanicDEFAULT
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_PanicDEFAULT(JNIEnv *env, jclass class, jobject fmtobj, jstring callfunc)
Java: [static] MkErrorC.PanicDEFAULT(?MkObjectC fmtobj = null?, ?String callfunc = null?...
Definition MkErrorC_jv.c:405
Java_jvmkkernel_MkErrorC_SetC
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetC(JNIEnv *env, jobject self, jstring message, jstring callfunc, jint errnum)
Java: err.SetC(String message, ?String callfunc = null?, ?int errnum = -1?) → C-API 'set' and '...
Definition MkErrorC_jv.c:362
Java_jvmkkernel_MkErrorC_PanicC
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_PanicC(JNIEnv *env, jclass class, jobject fmtobj, jstring callfunc, jint errnum, jstring message)
Java: [static] MkErrorC.PanicC(?MkObjectC fmtobj = null?, ?String callfunc = null?...
Definition MkErrorC_jv.c:385
Java_jvmkkernel_MkErrorC_AppendC
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_AppendC(JNIEnv *env, jobject self, jstring message)
Java: err.AppendC(String message) → C-API append the message to the MkErrorS::text …
Definition MkErrorC_jv.c:338
Java_jvmkkernel_MkErrorC_Raise
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Raise(JNIEnv *env, jobject self)
Java: err.Raise() → C-API convert an jvmkkernel error into an programming-language-error and ra...
Definition MkErrorC_jv.c:351
MkErrorIsSOCKET
bool MkErrorIsSOCKET(MK_ERRN const err)
check on SOCKET-DOWN error …
MkErrorIsABORT
bool MkErrorIsABORT(MK_ERRN const err)
check on ABORT signal …
MkErrorIsEXIT
bool MkErrorIsEXIT(MK_ERR const err)
check on APPLICATION-EXIT error …
MkErrorSetCONTINUE
#define MkErrorSetCONTINUE(...)
Definition kernel_overload_mk.h:1240
MkErrorIsTIMEOUT
bool MkErrorIsTIMEOUT(MK_ERRN const err)
check on TIMEOUT error …
MkErrorSetCode
#define MkErrorSetCode(...)
Definition kernel_overload_mk.h:1244
MkErrorSetEXIT
#define MkErrorSetEXIT(...)
Definition kernel_overload_mk.h:1248
MkErrorSetSOCKET
#define MkErrorSetSOCKET(...)
Definition kernel_overload_mk.h:1257
MkErrorSetABORT
#define MkErrorSetABORT(...)
Definition kernel_overload_mk.h:1228
Java_jvmkkernel_MkErrorC_SetCode
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetCode(JNIEnv *env, jobject self, jobject code)
Java: err.SetCode(MkErrorE code) → C-API set the MkErrorS::code value …
Definition MkErrorC_jv.c:510
Java_jvmkkernel_MkErrorC_SetCONTINUE
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetCONTINUE(JNIEnv *env, jobject self)
Java: err.SetCONTINUE() → C-API signal end of processing in an MqMqEventIF callback …
Definition MkErrorC_jv.c:500
Java_jvmkkernel_MkErrorC_IsEXIT
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsEXIT(JNIEnv *env, jobject self)
Java: boolean err.IsEXIT() → C-API check on APPLICATION-EXIT error …
Definition MkErrorC_jv.c:443
Java_jvmkkernel_MkErrorC_IsSOCKET
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsSOCKET(JNIEnv *env, jobject self)
Java: boolean err.IsSOCKET() → C-API check on SOCKET-DOWN error …
Definition MkErrorC_jv.c:455
Java_jvmkkernel_MkErrorC_SetSOCKET
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetSOCKET(JNIEnv *env, jobject self, jstring detail, jstring callfunc)
Java: err.SetSOCKET(?String detail = "UNKNOWN"?, ?String callfunc = null?) → C-API create SOCKE...
Definition MkErrorC_jv.c:540
Java_jvmkkernel_MkErrorC_IsABORT
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsABORT(JNIEnv *env, jobject self)
Java: boolean err.IsABORT() → C-API check on ABORT signal …
Definition MkErrorC_jv.c:431
Java_jvmkkernel_MkErrorC_IsTIMEOUT
JNIEXPORT jboolean JNICALL Java_jvmkkernel_MkErrorC_IsTIMEOUT(JNIEnv *env, jobject self)
Java: boolean err.IsTIMEOUT() → C-API check on TIMEOUT error …
Definition MkErrorC_jv.c:467
Java_jvmkkernel_MkErrorC_SetEXIT
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetEXIT(JNIEnv *env, jobject self, jstring callfunc)
Java: err.SetEXIT(?String callfunc = null?) → C-API finish the current callback,...
Definition MkErrorC_jv.c:522
Java_jvmkkernel_MkErrorC_SetABORT
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_SetABORT(JNIEnv *env, jobject self, jstring detail, jstring callfunc)
Java: err.SetABORT(?String detail = "UNKNOWN"?, ?String callfunc = null?) → C-API send the ABOR...
Definition MkErrorC_jv.c:479
MkErrorIGNORE
#define MkErrorIGNORE()
Definition kernel_overload_mk.h:1284
MkErrorDEFAULT
#define MkErrorDEFAULT()
Definition kernel_overload_mk.h:1278
MkErrorPRINT
#define MkErrorPRINT()
Definition kernel_overload_mk.h:1288
MkErrorFORMAT
MK_ERR MkErrorFORMAT(MK_OBJN fmtobj)
system-error-format - format and return the default-error …
Java_jvmkkernel_MkErrorC_IGNORE
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_IGNORE(JNIEnv *env, jclass class)
Java: [static] MkErrorC MkErrorC.IGNORE() → C-API ignore-system-error - ignore the next error …
Definition MkErrorC_jv.c:590
Java_jvmkkernel_MkErrorC_PRINT
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_PRINT(JNIEnv *env, jclass class)
Java: [static] MkErrorC MkErrorC.PRINT() → C-API ignore-system-error - print the next error into...
Definition MkErrorC_jv.c:598
Java_jvmkkernel_MkErrorC_FORMAT
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_FORMAT(JNIEnv *env, jclass class, jobject fmtobj)
Java: [static] MkErrorC MkErrorC.FORMAT(?MkObjectC fmtobj = null?) → C-API system-error-format -...
Definition MkErrorC_jv.c:578
Java_jvmkkernel_MkErrorC_DEFAULT
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_DEFAULT(JNIEnv *env, jclass class)
Java: [static] MkErrorC MkErrorC.DEFAULT() → C-API default-system-error - default-error …
Definition MkErrorC_jv.c:570
MkErrorCopy
#define MkErrorCopy(...)
Definition kernel_overload_mk.h:1310
MkErrorDup
#define MkErrorDup(...)
Definition kernel_overload_mk.h:1299
Java_jvmkkernel_MkErrorC_Copy
JNIEXPORT void JNICALL Java_jvmkkernel_MkErrorC_Copy(JNIEnv *env, jobject self, jobject srce)
Java: dest.Copy(MkErrorC srce) → C-API Copy-Constructor - sync an existing MkErrorC instance wi...
Definition MkErrorC_jv.c:633
Java_jvmkkernel_MkErrorC_Dup
JNIEXPORT jobject JNICALL Java_jvmkkernel_MkErrorC_Dup(JNIEnv *env, jobject self)
Java: [constructor] MkErrorC srce.Dup() → C-API Dup-Constructor - create a new MkErrorC instance...
Definition MkErrorC_jv.c:615
MkErrorDefaultC_TT
#define MkErrorDefaultC_TT
class as MkTypeS-class-type, useable in a class-macro as: class##_TT …
Definition LibMkKernel_mk.h:10597
MK_UNUSED
#define MK_UNUSED
mark unnused variables and functions
Definition LibMkKernel_mk.h:623
MkErrorE
MkErrorE
collection for the different error-codes …
Definition LibMkKernel_mk.h:1850
MkErrorE_ToString
MK_STRN MkErrorE_ToString(enum MkErrorE value)
return the MkErrorE as string …
MK_PTR
MK_PTRB * MK_PTR
generic pointer data-type
Definition LibMkKernel_mk.h:1387
MK_STRN
const MK_STRB * MK_STRN
constant string pointer data-type
Definition LibMkKernel_mk.h:1461
MK_BOOL
bool MK_BOOL
real bool data-type
Definition LibMkKernel_mk.h:1180
MK_SIZE
long MK_SIZE
Definition LibMkKernel_mk.h:1284
MK_I32
signed int MK_I32
4 byte integer data-type
Definition LibMkKernel_mk.h:1198
MK_OBJN
const struct MkObjectS * MK_OBJN
class-shortcut for const struct MkObjectS *, all const shortcut using the XX_YYYC syntax (only for pu...
Definition LibMkKernel_mk.h:1509
MkThreadLocal
#define MkThreadLocal
Definition LibMkKernel_mk.h:890
MK_RT_CALL
#define MK_RT_CALL
Definition LibMkKernel_mk.h:895
MkRtSetup_X
#define MkRtSetup_X(x)
Definition LibMkKernel_mk.h:12439
MK_RT_ARGS
#define MK_RT_ARGS
Definition LibMkKernel_mk.h:893
MkRtSetup_NULL
#define MkRtSetup_NULL
Definition LibMkKernel_mk.h:12442
MK_RT_ARGS_ONLY
#define MK_RT_ARGS_ONLY
Definition LibMkKernel_mk.h:892
MkErrorS
The data-type to store and handle the error-condition …
Definition LibMkKernel_mk.h:9710
MkObjectS
object header …
Definition LibMkKernel_mk.h:3381
Generated on Thu May 29 2025 13:13:25 for theKernel by doxygen 1.12.0