theLib 10.0
Loading...
Searching...
No Matches
libmyoox_mox.c
Go to the documentation of this file.
1
9/* LABEL-NO */
10
12#include <stdlib.h>
13#include <errno.h>
14
15/* LABEL-END */
16
17#define NamespaceTail(...) NS(NamespaceTailObjCmd)(__VA_ARGS__)
18mox_inline MOX_OBJ_T NS(NamespaceTailObjCmd)(MOX_OBJ_T nameO) {
19 MOX_STRN name = VAL2STR(nameO);
20 // from: NamespaceTailCmd --------------------------
21 MOX_STRN p;
22 for (p = name; *p != '\0'; p++) {
23 /* empty body */
24 }
25 while (--p > name) {
26 if ((*p == ':') && (*(p-1) == ':')) {
27 p++; /* Just after the last "::" */
28 break;
29 }
30 }
31
32 if (p >= name) {
33 name = p;
34 }
35 // ------------------------------------------------
36 return STR2VAL(name);
37}
38
39int NS(_InspectI) (MOX_CMD_ARGS)
40{
42 if (objc < (1+__skip)) {
43 Tcl_WrongNumArgs(interp,__skip,objv,"varName ...");
44 return TCL_ERROR;
45 }
46 char *NL="";
47 MOX_OBJ_T ret = Tcl_NewObj();
48 for (int i=1; i<objc ; i++) {
49 Tcl_AppendPrintfToObj(ret,"%s[%d] %s",NL,i,NS(_InspectI_direct)(objv[i]));
50 NL="\n";
51 }
52 Tcl_SetObjResult(interp,ret);
53 return TCL_OK;
54};
55
56// set Xname "$cls(__NAME__)-[incr cls(__INDEX__)]"
57#define MoxClsNewInstName() NS(ClsNewInstName)(interp,moxrt)
58mox_inline MOX_OBJ_T NS(ClsNewInstName)(MOX_ENV_T interp, MOX_RT_T moxrt) {
59 MOX_OBJ_T clsNmeO = MoxNsGetVar(cls,__NAME__);
60 if (clsNmeO == NULL) return NULL;
61 MOX_OBJ_T valO = MoxNsGetVar(cls,__INDEX__);
62 if (valO == NULL) return NULL;
63
64 static const Tcl_ObjType * longType = NULL;
65 long newLong;
66 if (longType == NULL || valO->typePtr != longType) {
67 if (Tcl_GetLongFromObj(interp,valO,&newLong)) return NULL;
68 longType = valO->typePtr;
69 }
70 if (Tcl_IsShared(valO)) {
71 newLong = valO->internalRep.longValue+1;
72 valO = MoxNsSetVar(cls,__INDEX__, Tcl_NewLongObj(newLong));
73 } else {
74 Tcl_InvalidateStringRep(valO);
75 newLong = ++valO->internalRep.longValue;
76 }
77#if MOX_USE_OBJ_PRINTF
78 return Tcl_ObjPrintf("%s-%ld", VAL2STR(clsNmeO), newLong);
79#else
80 char buf[256];
81 int lenI = snprintf(buf,256,"%s-%ld", VAL2STR(clsNmeO), newLong);
82 return Tcl_NewStringObj(buf,lenI);
83#endif
84}
85
91
92// proc ::myooX::ClassN { clsNs {Xcode ""} } {...
94 MOX_RT_T moxrt,
95 MOX_ENV_T interp,
96 MOX_OBJ_T clsNsO,
97 MOX_OBJ_T XcodeO
98) {
99 assert(clsNsO != NULL);
100 MOX_STRN clsNsC = VAL2STR(clsNsO);
101
102 // check if clsNsO is a valid tcl namespace
103 MOX_NS_T clsNsP = Tcl_FindNamespace(interp,clsNsC,NULL,TCL_GLOBAL_ONLY);
104 if (clsNsP==NULL) {
105 clsNsP = Tcl_CreateNamespace(interp,clsNsC,NULL,NULL);
106 if (clsNsP==NULL) return TCL_ERROR;
107 }
108
109 MOX_OBJ_T clsRefO = Tcl_ObjPrintf("%s::cls", clsNsC);
110 clsRefO = Tcl_ObjSetVar2(interp,moxrt->clsNs2Ref,clsNsO,clsRefO,TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG);
111 if (clsRefO == NULL) return TCL_ERROR;
112
113 int retI = TCL_ERROR;
114 #define MoxIsNotOk(cmd) ((retI=(cmd))!=TCL_OK)
115 MoxNsEval(clsNsP) {
116 // namespace path ::myooX
117 {
118 RL_init(3,ns_path, RL_NewC(0,namespace); RL_NewC(1,path); RL_NewS(2,"::myooX")) ;
119 if (MoxIsNotOk(RL_EvalEx(0))) break;
120 }
121
122 #define MoxSetVar(tok,val) if ( MoxNsSetVar(cls,tok,val) == NULL ) break
123 MoxSetVar(__NS__ , clsNsO) ; // set cls(__NS__) $clsNs
124 MoxSetVar(__NAME__ , NamespaceTail(clsNsO)) ; // set cls(__NAME__) [namespace tail $clsNs]
125 MoxSetVar(__SUPER__ , Tcl_NewObj()) ; // set cls(__SUPER__) ""
126 MoxSetVar(__NS_ALL_SORTED__ , Tcl_NewObj()) ; // set cls(__NS_ALL_SORTED__) ""
127 MoxSetVar(__INDEX__ , Tcl_NewIntObj(0)) ; // set cls(__INDEX__) 0
128 MoxSetVar(__CTOR__ , Tcl_NewObj()) ; // set cls(__CTOR__) ""
129 MoxSetVar(__DTOR__ , Tcl_NewObj()) ; // set cls(__DTOR__) ""
130 #undef MoxSetVar
131
132 // if {$Xcode ne ""} { ...
133 if (XcodeO && strcmp(VAL2STR(XcodeO),"")!=0) {
134 // namespace eval $clsNs $Xcode
135 if (MoxIsNotOk(Tcl_EvalObjEx(interp, XcodeO, 0))) break;
136 }
137
138 // # reset internal dependencies
139 // RecompileN $clsNs
140 {
141 RL_init(2,recompile, RL_NewC(0,RecompileN)) ; RL_O(1,clsNsO) ;
142 if (MoxIsNotOk(RL_EvalEx(0))) break;
143 }
144 }
145 MoxNsErrorCatch(clsNsP) {
146 return retI;
147 }
148 #undef MoxIsNotOk
149
150 return TCL_OK;
151}
152
153// proc ::myooX::ClassN { clsNs {Xcode ""} } {...
155{
157 if (objc < (1+__skip) || objc > (2+__skip)) {
158 Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ?Xcode?");
159 return TCL_ERROR;
160 }
161 MOX_OBJ_T clsNsO = objv[__skip++];
162 MOX_OBJ_T Xcode = __skip < objc ? objv[__skip++] : NULL;
163
164 return ClassN(clsNsO, Xcode);
165}
166
167// ---------------------------------------------------------------------------------------
168
169// proc ::myooX::MakeN { clsNs {Xname ""} {Xns ""} } {...
171 MOX_RT_T moxrt,
172 MOX_ENV_T interp,
173 MOX_OBJ_T clsNsO,
174 MOX_OBJ_T XnameO,
175 MOX_OBJ_T XnsO
176) {
177 Tcl_ResetResult(interp);
178 #if !MOX_USE_OBJ_PRINTF
179 char buf[256];
180 int lenI;
181 #endif
182
183 assert(clsNsO != NULL);
184 char* XnameC = XnameO != NULL ? VAL2STR(XnameO) : NULL;
185 char* XnsC = XnsO != NULL ? VAL2STR(XnsO) : NULL;
186 MOX_OBJ_T myNsO = NULL;
187 MOX_OBJ_T myNameO = NULL;
188
189 //if {$Xname eq ""} { ...
190 if (XnameC == NULL) {
191 // set Xname "$cls(__NAME__)-[incr cls(__INDEX__)]"
192 MOX_OBJ_T XnameO = MoxClsNewInstName();
193 if (XnameO == NULL) return NULL;
194 myNameO = XnameO;
195 Tcl_IncrRefCount(myNameO);
196
197 // if {$Xns eq ""} { ...
198 if (XnsC == NULL) {
199 // set myNs "${clsNs}::$Xname"
200 #if MOX_USE_OBJ_PRINTF
201 myNsO = Tcl_ObjPrintf("%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO));
202 #else
203 lenI = snprintf(buf,256,"%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO));
204 myNsO = Tcl_NewStringObj(buf,lenI);
205 #endif
206 } else {
207 // set myNs "${Xns}::$Xname"
208 #if MOX_USE_OBJ_PRINTF
209 myNsO = Tcl_ObjPrintf("%s::%s", XnsC, VAL2STR(XnameO));
210 #else
211 lenI = snprintf(buf,256,"%s::%s", XnsC, VAL2STR(XnameO));
212 myNsO = Tcl_NewStringObj(buf,lenI);
213 #endif
214 }
215 Tcl_IncrRefCount(myNsO);
216
217 // } elseif {[string match ::* $Xname]} { ...
218 } else if (XnameC[0] == ':' && XnameC[1] == ':') {
219 // set myNs "$Xname"
220 myNsO = XnameO;
221 Tcl_IncrRefCount(myNsO);
222 myNameO = NamespaceTail(myNsO);
223 Tcl_IncrRefCount(myNameO);
224
225 // } elseif {$Xns eq ""} { ...
226 } else if (XnsC == NULL) {
227 // set myNs "${clsNs}::$Xname"
228 #if MOX_USE_OBJ_PRINTF
229 myNsO = Tcl_ObjPrintf("%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO));
230 #else
231 lenI = snprintf(buf,256,"%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO));
232 myNsO = Tcl_NewStringObj(buf,lenI);
233 #endif
234 Tcl_IncrRefCount(myNsO);
235 myNameO = XnameO;
236 Tcl_IncrRefCount(myNameO);
237
238 // } else { ...
239 } else {
240 // set myNs "${Xns}::$Xname"
241 #if MOX_USE_OBJ_PRINTF
242 myNsO = Tcl_ObjPrintf("%s::%s", XnsC, VAL2STR(XnameO));
243 #else
244 lenI = snprintf(buf,256,"%s::%s", XnsC, VAL2STR(XnameO));
245 myNsO = Tcl_NewStringObj(buf,lenI);
246 #endif
247 Tcl_IncrRefCount(myNsO);
248 myNameO = XnameO;
249 Tcl_IncrRefCount(myNameO);
250 }
251
252 MOX_STRN myNsC = VAL2STR(myNsO);
253
254 MOX_NS_T myNsPtr = Tcl_FindNamespace(interp,myNsC,NULL,TCL_GLOBAL_ONLY);
255
256 // if {![namespace exists $myNs]} { ...
257 if (myNsPtr == NULL) {
258
259 myNsPtr = Tcl_CreateNamespace(interp,myNsC,NULL /*ClientData*/, NULL /*ClientProc*/);
260 if (myNsPtr == NULL) goto error;
261
262 MoxNsEval(myNsPtr) {
263
264 #define MoxSetVar(tok,val) \
265 if ( MoxNsSetVar(my,tok,val) == NULL ) break
266 MoxSetVar(__NS__, myNsO); // __NS__ $myNs
267 MoxSetVar(__NAME__, myNameO); // __NAME__ [namespace tail $myNs]
268 MoxSetVar(__CLASS__, clsNsO); // __CLASS__ $clsNs
269 #undef MoxSetVar
270
271 }
272
273 MoxNsErrorCatch(myNsPtr) {
274 goto error;
275 }
276 }
277
278 // set myNs
279 Tcl_SetObjResult(interp,myNsO);
280
281error:
282 if (myNsO) Tcl_DecrRefCount(myNsO);
283 if (myNameO) Tcl_DecrRefCount(myNameO);
284 return myNsO;
285}
286
289 MOX_RT_T moxrt,
290 MOX_ENV_T interp,
291 MOX_OBJ_T clsNsO,
292 MOX_OBJ_T Xname,
293 MOX_OBJ_T Xns
294) {
295 assert(moxrt != NULL);
296 assert(interp != NULL);
297 assert(clsNsO != NULL);
298
299 MOX_OBJ_T myNsO=NULL;
300
301 MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
302 if (clsNsPtr == NULL) return NULL;
303
304 MoxPushN(clsNsPtr);
305
306 // MoxMakeN $clsNs
307 myNsO = MoxMakeNNN(clsNsO, Xname, Xns);
308
309 MoxPopN();
310
311 return myNsO;
312}
313
314// proc ::myooX::MakeN { clsNs {Xname ""} {Xns ""} } {...
315int NS(MakeN) (MOX_CMD_ARGS) {
317 if (objc < (1+__skip) || objc > (3+__skip)) {
318 Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ?instName? ?instNs?");
319 return TCL_ERROR;
320 }
321 MOX_OBJ_T clsNsO = objv[__skip++];
322 MOX_OBJ_T XnameO = __skip < objc ? objv[__skip++] : NULL;
323 MOX_OBJ_T XnsO = __skip < objc ? objv[__skip++] : NULL;
324
325 MOX_OBJ_T retO = MoxMakeNNN(clsNsO, XnameO, XnsO);
326 if (retO == NULL) return TCL_ERROR;
327
328 return TCL_OK;
329}
330
331// ---------------------------------------------------------------------------------------
332
333// proc ::myooX::CtorN { clsNs myRef argsL } { ...
334#define CtorNNN_direct(...) NS(CtorNNN_direct)(moxrt,interp,__VA_ARGS__)
335static int NS(CtorNNN_direct) (
336 MOX_RT_T moxrt,
337 MOX_ENV_T interp,
338 MOX_OBJ_T myNsO,
339 int argc,
340 const MOX_OBJ_T *argv
341) {
342 MOX_OBJ_T ctorO = MoxNsGetVar(cls,__CTOR__);
343 if (ctorO == NULL) return TCL_ERROR;
344 MOX_STRN ctorC = VAL2STR(ctorO);
345
346 // if {$cls(__CTOR__) ne ""} {
347 if (ctorC[0] != '\0') {
348 // $cls(__CTOR__) $myRef {*}$argsL
349 RL_init(16, ctor_eval, ) ; RL_O(0,ctorO) ; RL_O(1,myNsO) ; RL_args(2,argc,argv);
350 int retR = RL_EvalEx(TCL_EVAL_GLOBAL);
351
352 // on error {err opt} {
353 if (retR == TCL_ERROR) {
354 // _ErrorCatchCtorFailedN $myNs $err $opt
355 MOX_OBJ_T errOptO = Tcl_GetReturnOptions(interp,retR);
356 RL_init(4, ctor_catch, RL_NewS(0,"_ErrorCatchCtorFailedN"); RL_NewS(1,"CtorN"));
357 RL_O(2,myNsO); RL_O(3,errOptO);
358 RL_EvalEx(0);
359 return TCL_ERROR;
360 }
361
362 // } elseif {[llength $argsL]} {
363 } else if (argc) {
364 // _ErrorRaiseCtorInvalidArgumentN $myNs $argsL
365 RL_init(4, ctor_raise, RL_NewS(0,"_ErrorRaiseCtorInvalidArgumentN"); RL_NewS(1,"CtorN"));
366 RL_O(2,myNsO); RL_NewL(3,argc,argv);
367 RL_EvalEx(0);
368 return TCL_ERROR;
369 }
370 // set myRef
371 Tcl_SetObjResult(interp,myNsO);
372 return TCL_OK;
373}
374
375// proc ::myooX::CtorN { clsNs myRef argsL } { ...
376int NS(CtorN) (MOX_CMD_ARGS) {
378 if (objc < (3+__skip) || objc > (3+__skip)) {
379 Tcl_WrongNumArgs(interp,__skip,objv,"clsNs myRef argsL");
380 return TCL_ERROR;
381 }
382 MOX_OBJ_T clsNsO = objv[__skip++];
383 MOX_OBJ_T myNsO = objv[__skip++];
384 MOX_OBJ_T argsLO = objv[__skip++];
385
386 int ret;
387
388 int argc; MOX_OBJ_T *argv;
389 ret = Tcl_ListObjGetElements(interp,argsLO, &argc, &argv);
390 if (ret == TCL_ERROR) return TCL_ERROR;
391
392 MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
393 if (clsNsPtr == NULL) return TCL_ERROR;
394
395 MoxPushN(clsNsPtr);
396 ret = CtorNNN_direct(myNsO,argc,argv);
397 MoxPopN();
398
399 return ret;
400}
401
402// ---------------------------------------------------------------------------------------
403// proc ::myooX::DestroyN { myNs } { ...
404int NS(DestroyN_direct) (MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T myNsO) {
405
406 MOX_NS_T myNsPtr = MoxResolveN(myNsO);
407 if (myNsPtr == NULL) return TCL_ERROR;
408
409 MoxNsEval(myNsPtr) {
410 MOX_OBJ_T clsNsO = MoxNsGetVar(my,__CLASS__);
411 if (clsNsO == NULL) break;
412
413 MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
414 if (clsNsPtr == NULL) break;
415
416 MoxNsEval(clsNsPtr) {
417
418 MOX_OBJ_T dtorO = MoxNsGetVar(cls,__DTOR__);
419 if (dtorO == NULL) break;
420 MOX_STRN dtorC = VAL2STR(dtorO);
421
422 // if {$cls(__DTOR__) ne ""} { ...
423 if (dtorC[0] != '\0') {
424 // $cls(__DTOR__) $myRef
425 RL_init(2, destroy_eval, ) ; RL_O(0,dtorO) ; RL_O(1,myNsO) ;
426 int retR = RL_EvalEx(TCL_EVAL_GLOBAL);
427
428 // on error {err opt} { ...
429 if (retR == TCL_ERROR) {
430 // _ErrorCatchDtorFailedN $myNs $err $opt
431 MOX_OBJ_T errOptO = Tcl_GetReturnOptions(interp,retR);
432 RL_init(4, destroy_catch, RL_NewS(0,"_ErrorCatchDtorFailedN"); RL_NewS(1,"DestroyN") );
433 RL_O(2,myNsO); RL_O(3,errOptO);
434 RL_EvalEx(0);
435 break;
436 }
437 }
438 }
439 MoxNsErrorCatch(clsNsPtr) {
440 break;
441 }
442 }
443
444 MoxNsErrorCatch(myNsPtr) {
445 return TCL_ERROR;
446 }
447
448 // namespace delete $my(__NS__)
449 Tcl_DeleteNamespace(myNsPtr);
450
451 Tcl_FreeResult(interp);
452 return TCL_OK;
453}
454
455// proc ::myooX::DestroyN { myNs } { ...
456int NS(DestroyN) (MOX_CMD_ARGS) {
458
459 if (objc < (1+__skip) || objc > (1+__skip)) {
460 Tcl_WrongNumArgs(interp,__skip,objv,"myNs");
461 return TCL_ERROR;
462 }
463
464 MOX_OBJ_T myNsO = objv[__skip++];
465
466 return MoxDestroyN(myNsO);
467}
468
469// ---------------------------------------------------------------------------------------
470// proc ::myooX::Create3N {clsNs Xname Xns args} { ...
472 MOX_RT_T moxrt,
473 MOX_ENV_T interp,
474 MOX_OBJ_T clsNsO,
475 MOX_OBJ_T Xname,
476 MOX_OBJ_T Xns,
477 int objc,
478 const MOX_OBJ_T* objv
479) {
480 assert(moxrt != NULL);
481 assert(interp != NULL);
482 assert(clsNsO != NULL);
483
484 MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
485 if (clsNsPtr == NULL) return TCL_ERROR;
486
487 MoxNsEval(clsNsPtr) {
488
489 // MoxMakeN $clsNs
490 MOX_OBJ_T myNsO = MoxMakeNNN(clsNsO, Xname, Xns);
491 if (myNsO == NULL) break;
492
493 // CtorN $clsNs $myRef ...
494 Tcl_IncrRefCount(myNsO);
495 int retI = CtorNNN_direct(myNsO, objc, objv);
496 Tcl_DecrRefCount(myNsO);
497 if ( retI == TCL_ERROR ) break;
498 }
499
500 MoxNsErrorCatch(clsNsPtr) {
501 return TCL_ERROR;
502 }
503
504 return TCL_OK;
505}
506
507// proc ::myooX::Create3N {clsNs Xname Xns args} { ...
508int NS(Create3N) (MOX_CMD_ARGS) {
510 if (objc < (3+__skip)) {
511 Tcl_WrongNumArgs(interp,__skip,objv,"clsNs Xname Xns ...");
512 return TCL_ERROR;
513 }
514 MOX_OBJ_T clsNsO = objv[__skip++];
515 MOX_OBJ_T XnameO = objv[__skip++];
516 MOX_OBJ_T XnsO = objv[__skip++];
517
518 return MoxCreate3N(clsNsO,XnameO,XnsO,objc-4,objv+4);
519}
520
521// proc ::myooX::Create2N {clsNs Xname args} { ...
522int NS(Create2N) (MOX_CMD_ARGS) {
524 if (objc < (2+__skip)) {
525 Tcl_WrongNumArgs(interp,__skip,objv,"clsNs Xname ...");
526 return TCL_ERROR;
527 }
528 MOX_OBJ_T clsNsO = objv[__skip++];
529 MOX_OBJ_T XnameO = objv[__skip++];
530
531 return MoxCreate3N(clsNsO,XnameO,NULL,objc-3,objv+3);
532}
533
534// proc ::myooX::Create1N {clsNs args} { ...
535int NS(Create1N) (MOX_CMD_ARGS) {
537
538 if (objc < (1+__skip)) {
539 Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ...");
540 return TCL_ERROR;
541 }
542 MOX_OBJ_T clsNsO = objv[__skip++];
543
544 return MoxCreate3N(clsNsO,NULL,NULL,objc-2,objv+2);
545}
546
547// proc ::myooX::NewN {clsNs args} { ...
548int NS(NewN) (MOX_CMD_ARGS) {
550
551 if (objc < (1+__skip)) {
552 Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ...");
553 return TCL_ERROR;
554 }
555 MOX_OBJ_T clsNsO = objv[__skip++];
556
557 return MoxCreate3N(clsNsO,NULL,NULL,objc-2,objv+2);
558}
559
565
566static void NS(ApiNsDelete) (MOX_PTR clientData) {
567 MOX_RT_T moxrt = clientData;
568 moxrt->myooxNs = NULL;
569 //moxrt->status = MOX_RT_STATUS_ONEXIT;
570 if (moxrt->myooxNs) Tcl_DeleteNamespace(moxrt->myooxNs);
571
572 #define MoxRtFree(tok) if (moxrt->tok) Tcl_DecrRefCount(moxrt->tok)
573 #define regTclObj2(t,v) MoxRtFree(t)
574 #define regTclObj(t) MoxRtFree(t)
575 #define regTclCmd(t) MoxRtFree(t)
576 #include "libmyoox_registry_mox.h"
577 #undef regTclCmd
578 #undef regTclObj
579 #undef regTclObj2
580
581 //moxrt->status = MOX_RT_STATUS_DELETED;
582 moxrt->signature = 0x0;
583 //free(moxrt);
584}
585
586// load /path/to/libmyoox.so
587MOX_EXTERN int _Myoox_Init ( MOX_ENV_T interp )
588{
589 // check for the right tcl version
590 if (Tcl_InitStubs (interp, "8.5", 0) == NULL) return TCL_ERROR;
591
592 // announce my package
593 if (Tcl_PkgProvide (interp, "libmyoox", "1.0" ) == TCL_ERROR) return TCL_ERROR;
594
595 // pkg_mkIndex hack → only "Tcl_PkgProvide" is required
596 if (Tcl_GetVar(interp,"::tcl::newPkgs", TCL_GLOBAL_ONLY) != NULL) return TCL_OK;
597
598 // dependency.
599 if (Tcl_PkgRequire(interp, "tclmyoox", "1.0", 0) == NULL) return TCL_ERROR;
600
601 // local cache
602 MOX_RT_T moxrt = calloc(1,sizeof(*moxrt));
603 if (moxrt == NULL) {
604 Tcl_SetErrorCode(interp, "MYOOX", "SETUP", "ALLOC");
605 Tcl_SetResult(interp,"error: myooX setup failed with '", TCL_STATIC);
606 Tcl_AppendResult(interp,Tcl_ErrnoMsg(errno),"'",NULL);
607 return TCL_ERROR;
608 }
609 moxrt->signature = MOX_RT_SIG;
610 moxrt->interp = interp;
611
612 // register "access" objects
613 #define regTclObj2(t,v) moxrt->t = STR2VAL(v); Tcl_IncrRefCount(moxrt->t)
614 #define regTclObj(t) regTclObj2(t,#t)
615 #define regTclCmd(t) regTclObj2(t,#t)
616 #include "libmyoox_registry_mox.h"
617 #undef regTclCmd
618 #undef regTclObj
619 #undef regTclObj2
620
621 // toplevel namespace
622 MOX_NS_T ns = Tcl_FindNamespace(interp,"::myooX",NULL,TCL_GLOBAL_ONLY);
623 if (ns == NULL) {
624 ns = Tcl_CreateNamespace(interp, "::myooX",NULL,NULL);
625 if (ns==NULL) return TCL_ERROR;
626 }
627 ns->clientData = moxrt;
628 ns->deleteProc = NS(ApiNsDelete);
629 moxrt->myooxNs = ns;
630
631 // add PACKAGE commands
632
633 Tcl_Command cmd;
634
635 #define MoxObjCmd(nme) do { \
636 cmd = Tcl_CreateObjCommand(interp, "::myooX::" #nme, NS(nme), moxrt, NULL) ; \
637 if (cmd == NULL) return TCL_ERROR; \
638 } while (0)
639
640 MoxObjCmd(_InspectI);
641 #define regTclCmd(t) MoxObjCmd(t)
642 #include "libmyoox_registry_mox.h"
643 #undef regTclCmd
644
645 return TCL_OK;
646}
647
648// unload /path/to/libmyoox.so
649MOX_EXTERN int _Myoox_Unload ( MOX_ENV_T interp, int flags)
650{
651 MOX_NS_T ns = Tcl_FindNamespace(interp,"::myooX",NULL,TCL_GLOBAL_ONLY);
652 if (ns != NULL) Tcl_DeleteNamespace(ns);
653 return TCL_OK;
654}
#define CtorNNN_direct(...)
#define NamespaceTail(...)
#define MoxIsNotOk(cmd)
#define MoxClsNewInstName()
MOX_EXTERN int _Myoox_Unload(MOX_ENV_T interp, int flags)
#define MoxObjCmd(nme)
#define MoxSetVar(tok, val)
#define MoxPushN(...)
#define MoxNsSetVar(ns, tok, new)
#define MoxMakeNNN(...)
The "NN" code require that the "clsNsO" is already set in the "interp".
#define mox_inline
#define MOX_CMD_ARGS
ClientData MOX_PTR
#define MoxPopN()
#define MoxCreate3N(...)
#define MOX_EXTERN
static library
MOX_EXTERN MOX_OBJ_T MOX_DECL MOX MakeN_direct(MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T XnameO, MOX_OBJ_T XnsO)
Tcl_Interp * MOX_ENV_T
#define MoxNsErrorCatch(_nsPtr)
#define NS(n)
MOX_EXTERN int MOX_DECL MOX DestroyN_direct(MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T myNsO)
#define MoxResolveN(nsO)
MOX_EXTERN MOX_OBJ_T MOX_DECL MOX MakeNNN_direct(MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T XnameO, MOX_OBJ_T XnsO)
#define MoxNsEval(_nsPtr)
#define MoxNsGetVar(ns, tok)
Tcl_Obj * MOX_OBJ_T
const char * MOX_STRN
#define ClassN(...)
Tcl_Namespace * MOX_NS_T
MOX_EXTERN int MOX_DECL MOX Create3N_direct(MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T XnameO, MOX_OBJ_T XnsO, int objc, const MOX_OBJ_T *objv)
#define MoxDestroyN(...)
#define MOX_RT_SIG
MOX_EXTERN int MOX_DECL MOX ClassN_direct(MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T XcodeO)
tag: nhi1-release-250425
#define MOX_SETUP_hdl_static
#define VAL2STR(val)
#define STR2VAL(str)
tag: nhi1-release-250425
#define RL_NewS(num, s)
Definition rl_mox.h:38
#define RL_args(start, _c, _v)
Definition rl_mox.h:45
#define RL_EvalEx(f)
Definition rl_mox.h:61
#define RL_O(num, l)
Definition rl_mox.h:41
#define RL_NewL(num, c, v)
Definition rl_mox.h:39
#define RL_NewC(num, s)
Definition rl_mox.h:42
#define RL_init(max, ref, code)
Definition rl_mox.h:17
MOX_NS_T myooxNs
MOX_ENV_T interp