libmyoox_mox.c File Reference

tag: nhi1-release-250425 More...

#include "libmyoox_private_mox.h"
#include <stdlib.h>
#include <errno.h>
#include "libmyoox_registry_mox.h"

Include dependency graph for libmyoox_mox.c:

Go to the source code of this file.

Macros
#define	NamespaceTail(...)
#define	MoxClsNewInstName()
#define	MoxIsNotOk(cmd)
#define	MoxSetVar(tok, val)
#define	MoxSetVar(tok, val)
#define	CtorNNN_direct(...)
#define	MoxRtFree(tok)
#define	regTclObj2(t, v)
#define	regTclObj(t)
#define	regTclCmd(t)
#define	regTclObj2(t, v)
#define	regTclObj(t)
#define	regTclCmd(t)
#define	MoxObjCmd(nme)
#define	regTclCmd(t)

Functions
mox_inline MOX_OBJ_T	libmyoox_NamespaceTailObjCmd (MOX_OBJ_T nameO)
int	libmyoox__InspectI (MOX_CMD_ARGS)
mox_inline MOX_OBJ_T	libmyoox_ClsNewInstName (MOX_ENV_T interp, MOX_RT_T moxrt)
int	libmyoox_ClassN_direct (MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T XcodeO)
int	libmyoox_ClassN (MOX_CMD_ARGS)
MOX_OBJ_T	libmyoox_MakeNNN_direct (MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T XnameO, MOX_OBJ_T XnsO)
MOX_OBJ_T	libmyoox_MakeN_direct (MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T Xname, MOX_OBJ_T Xns)
	used in public code
int	libmyoox_MakeN (MOX_CMD_ARGS)
static int	libmyoox_CtorNNN_direct (MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T myNsO, int argc, const MOX_OBJ_T *argv)
int	libmyoox_CtorN (MOX_CMD_ARGS)
int	libmyoox_DestroyN_direct (MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T myNsO)
int	libmyoox_DestroyN (MOX_CMD_ARGS)
int	libmyoox_Create3N_direct (MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T clsNsO, MOX_OBJ_T Xname, MOX_OBJ_T Xns, int objc, const MOX_OBJ_T *objv)
int	libmyoox_Create3N (MOX_CMD_ARGS)
int	libmyoox_Create2N (MOX_CMD_ARGS)
int	libmyoox_Create1N (MOX_CMD_ARGS)
int	libmyoox_NewN (MOX_CMD_ARGS)
MOX_EXTERN int	_Myoox_Unload (MOX_ENV_T interp, int flags)

Detailed Description

tag: nhi1-release-250425

Copyright

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

Definition in file libmyoox_mox.c.

Macro Definition Documentation

CtorNNN_direct

#define CtorNNN_direct

(

...

)

Value:

NS(CtorNNN_direct)(moxrt,interp,__VA_ARGS__)

Definition at line 334 of file libmyoox_mox.c.

MoxClsNewInstName

#define MoxClsNewInstName

(

)

Value:

NS(ClsNewInstName)(interp,moxrt)

Definition at line 57 of file libmyoox_mox.c.

MoxIsNotOk

#define MoxIsNotOk

(

cmd

)

Value:

((retI=(cmd))!=TCL_OK)

MoxObjCmd

#define MoxObjCmd

(

nme

)

Value:

    do { \
    cmd = Tcl_CreateObjCommand(interp, "::myooX::" #nme, NS(nme), moxrt, NULL) ; \
    if (cmd == NULL) return TCL_ERROR; \
  } while (0)

MoxRtFree

#define MoxRtFree

(

tok

)

Value:

if (moxrt->tok) Tcl_DecrRefCount(moxrt->tok)

MoxSetVar [1/2]

#define MoxSetVar	(		tok,
			val )

Value:

if ( MoxNsSetVar(cls,tok,val) == NULL ) break

MoxSetVar [2/2]

#define MoxSetVar	(		tok,
			val )

Value:

        if ( MoxNsSetVar(my,tok,val) == NULL ) break

NamespaceTail

#define NamespaceTail

(

...

)

Value:

NS(NamespaceTailObjCmd)(__VA_ARGS__)

Definition at line 17 of file libmyoox_mox.c.

regTclCmd [1/3]

#define regTclCmd

(

t

)

Value:

MoxRtFree(t)

regTclCmd [2/3]

#define regTclCmd

(

t

)

Value:

regTclObj2(t,#t)

regTclCmd [3/3]

#define regTclCmd

(

t

)

Value:

MoxObjCmd(t)

regTclObj [1/2]

#define regTclObj

(

t

)

Value:

MoxRtFree(t)

regTclObj [2/2]

#define regTclObj

(

t

)

Value:

regTclObj2(t,#t)

regTclObj2 [1/2]

#define regTclObj2	(		t,
			v )

Value:

MoxRtFree(t)

regTclObj2 [2/2]

#define regTclObj2	(		t,
			v )

Value:

moxrt->t = STR2VAL(v); Tcl_IncrRefCount(moxrt->t)

Function Documentation

_Myoox_Unload()

MOX_EXTERN int _Myoox_Unload	(	MOX_ENV_T	interp,
		int	flags )

Definition at line 649 of file libmyoox_mox.c.

{
  MOX_NS_T ns = Tcl_FindNamespace(interp,"::myooX",NULL,TCL_GLOBAL_ONLY);
    if (ns != NULL) Tcl_DeleteNamespace(ns);
  return TCL_OK;
}

libmyoox__InspectI()

int libmyoox__InspectI

(

MOX_CMD_ARGS

)

Definition at line 39 of file libmyoox_mox.c.

{
  MOX_SETUP_hdl_static;
  if (objc < (1+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"varName ...");
    return TCL_ERROR;
  }
  char *NL="";
  MOX_OBJ_T ret = Tcl_NewObj();
  for (int i=1; i<objc ; i++) {
    Tcl_AppendPrintfToObj(ret,"%s[%d] %s",NL,i,NS(_InspectI_direct)(objv[i]));
    NL="\n";
  }
  Tcl_SetObjResult(interp,ret);
  return TCL_OK;
};

libmyoox_ClassN()

int libmyoox_ClassN

(

MOX_CMD_ARGS

)

Definition at line 154 of file libmyoox_mox.c.

{
  MOX_SETUP_hdl_static;
  if (objc < (1+__skip) || objc > (2+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ?Xcode?");
    return TCL_ERROR;
  }
  MOX_OBJ_T clsNsO  = objv[__skip++];
  MOX_OBJ_T Xcode   = __skip < objc ? objv[__skip++] : NULL;
 
  return ClassN(clsNsO, Xcode);
}

libmyoox_ClassN_direct()

int libmyoox_ClassN_direct	(	MOX_RT_T	moxrt,
		MOX_ENV_T	interp,
		MOX_OBJ_T	clsNsO,
		MOX_OBJ_T	XcodeO )

MARK_C CODE

Definition at line 93 of file libmyoox_mox.c.

  {
  assert(clsNsO != NULL);
  MOX_STRN clsNsC = VAL2STR(clsNsO);
 
  // check if clsNsO is a valid tcl namespace
  MOX_NS_T clsNsP = Tcl_FindNamespace(interp,clsNsC,NULL,TCL_GLOBAL_ONLY);
    if (clsNsP==NULL) {
      clsNsP = Tcl_CreateNamespace(interp,clsNsC,NULL,NULL);
        if (clsNsP==NULL) return TCL_ERROR;
    }
 
  MOX_OBJ_T clsRefO = Tcl_ObjPrintf("%s::cls", clsNsC); 
  clsRefO = Tcl_ObjSetVar2(interp,moxrt->clsNs2Ref,clsNsO,clsRefO,TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG);
    if (clsRefO == NULL) return TCL_ERROR;
 
  int retI = TCL_ERROR;
  #define MoxIsNotOk(cmd) ((retI=(cmd))!=TCL_OK)
  MoxNsEval(clsNsP) {
    // namespace path ::myooX
    {
      RL_init(3,ns_path, RL_NewC(0,namespace); RL_NewC(1,path); RL_NewS(2,"::myooX")) ;
        if (MoxIsNotOk(RL_EvalEx(0))) break;
    }
        
    #define MoxSetVar(tok,val)    if ( MoxNsSetVar(cls,tok,val) == NULL ) break
      MoxSetVar(__NS__            , clsNsO)                 ; // set cls(__NS__)             $clsNs
      MoxSetVar(__NAME__          , NamespaceTail(clsNsO))  ; // set cls(__NAME__)           [namespace tail $clsNs]
      MoxSetVar(__SUPER__         , Tcl_NewObj())           ; // set cls(__SUPER__)          ""
      MoxSetVar(__NS_ALL_SORTED__ , Tcl_NewObj())           ; // set cls(__NS_ALL_SORTED__)  ""
      MoxSetVar(__INDEX__         , Tcl_NewIntObj(0))       ; // set cls(__INDEX__)          0
      MoxSetVar(__CTOR__          , Tcl_NewObj())           ; // set cls(__CTOR__)           ""
      MoxSetVar(__DTOR__          , Tcl_NewObj())           ; // set cls(__DTOR__)           ""
    #undef MoxSetVar
 
    // if {$Xcode ne ""} { ...
    if (XcodeO && strcmp(VAL2STR(XcodeO),"")!=0) {
      // namespace eval $clsNs $Xcode
      if (MoxIsNotOk(Tcl_EvalObjEx(interp, XcodeO, 0))) break;
    }
 
    // # reset internal dependencies
    // RecompileN $clsNs
    {
      RL_init(2,recompile, RL_NewC(0,RecompileN)) ; RL_O(1,clsNsO) ;
        if (MoxIsNotOk(RL_EvalEx(0))) break;
    }
  }
  MoxNsErrorCatch(clsNsP) {
    return retI;
  }
  #undef MoxIsNotOk
 
  return TCL_OK;
}

libmyoox_ClsNewInstName()

mox_inline MOX_OBJ_T libmyoox_ClsNewInstName	(	MOX_ENV_T	interp,
		MOX_RT_T	moxrt )

Definition at line 58 of file libmyoox_mox.c.

                                                                          {
  MOX_OBJ_T clsNmeO = MoxNsGetVar(cls,__NAME__);
    if (clsNmeO == NULL) return NULL;
  MOX_OBJ_T valO = MoxNsGetVar(cls,__INDEX__);
    if (valO == NULL) return NULL;
 
  static const Tcl_ObjType * longType = NULL;
  long newLong;
  if (longType == NULL || valO->typePtr != longType) {
    if (Tcl_GetLongFromObj(interp,valO,&newLong)) return NULL;
    longType = valO->typePtr;
  }
  if (Tcl_IsShared(valO)) {
    newLong = valO->internalRep.longValue+1;
    valO = MoxNsSetVar(cls,__INDEX__, Tcl_NewLongObj(newLong));
  } else {
    Tcl_InvalidateStringRep(valO);
    newLong = ++valO->internalRep.longValue;
  }
#if MOX_USE_OBJ_PRINTF
  return Tcl_ObjPrintf("%s-%ld", VAL2STR(clsNmeO), newLong);
#else
  char buf[256];
    int lenI = snprintf(buf,256,"%s-%ld", VAL2STR(clsNmeO), newLong);
  return Tcl_NewStringObj(buf,lenI);
#endif
}

libmyoox_Create1N()

int libmyoox_Create1N

(

MOX_CMD_ARGS

)

Definition at line 535 of file libmyoox_mox.c.

                                {
  MOX_SETUP_hdl_static;
 
  if (objc < (1+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ...");
    return TCL_ERROR;
  }
  MOX_OBJ_T clsNsO = objv[__skip++];
 
  return MoxCreate3N(clsNsO,NULL,NULL,objc-2,objv+2);
}

libmyoox_Create2N()

int libmyoox_Create2N

(

MOX_CMD_ARGS

)

Definition at line 522 of file libmyoox_mox.c.

                                {
  MOX_SETUP_hdl_static;
  if (objc < (2+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"clsNs Xname ...");
    return TCL_ERROR;
  }
  MOX_OBJ_T clsNsO = objv[__skip++];
  MOX_OBJ_T XnameO = objv[__skip++];
 
  return MoxCreate3N(clsNsO,XnameO,NULL,objc-3,objv+3);
}

libmyoox_Create3N()

int libmyoox_Create3N

(

MOX_CMD_ARGS

)

Definition at line 508 of file libmyoox_mox.c.

                                {
  MOX_SETUP_hdl_static;
  if (objc < (3+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"clsNs Xname Xns ...");
    return TCL_ERROR;
  }
  MOX_OBJ_T clsNsO  = objv[__skip++];
  MOX_OBJ_T XnameO  = objv[__skip++];
  MOX_OBJ_T XnsO    = objv[__skip++];
 
  return MoxCreate3N(clsNsO,XnameO,XnsO,objc-4,objv+4);
}

libmyoox_Create3N_direct()

int libmyoox_Create3N_direct	(	MOX_RT_T	moxrt,
		MOX_ENV_T	interp,
		MOX_OBJ_T	clsNsO,
		MOX_OBJ_T	Xname,
		MOX_OBJ_T	Xns,
		int	objc,
		const MOX_OBJ_T *	objv )

Definition at line 471 of file libmyoox_mox.c.

  {
  assert(moxrt  != NULL);
  assert(interp != NULL);
  assert(clsNsO != NULL);
 
  MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
    if (clsNsPtr == NULL) return TCL_ERROR;
 
  MoxNsEval(clsNsPtr) {
 
    // MoxMakeN $clsNs
    MOX_OBJ_T myNsO = MoxMakeNNN(clsNsO, Xname, Xns);
      if (myNsO == NULL) break;
 
    // CtorN $clsNs $myRef ...
    Tcl_IncrRefCount(myNsO);
    int retI = CtorNNN_direct(myNsO, objc, objv);
    Tcl_DecrRefCount(myNsO);
      if ( retI == TCL_ERROR ) break;  
  }
 
  MoxNsErrorCatch(clsNsPtr) {
    return TCL_ERROR;
  }
 
  return TCL_OK;
}

libmyoox_CtorN()

int libmyoox_CtorN

(

MOX_CMD_ARGS

)

Definition at line 376 of file libmyoox_mox.c.

                             {
  MOX_SETUP_hdl_static;
  if (objc < (3+__skip) || objc > (3+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"clsNs myRef argsL");
    return TCL_ERROR;
  }
  MOX_OBJ_T clsNsO  = objv[__skip++];
  MOX_OBJ_T myNsO   = objv[__skip++];
  MOX_OBJ_T argsLO  = objv[__skip++];
 
  int ret;
 
  int argc; MOX_OBJ_T *argv;
    ret = Tcl_ListObjGetElements(interp,argsLO, &argc, &argv);
      if (ret == TCL_ERROR) return TCL_ERROR;
 
  MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
    if (clsNsPtr == NULL) return TCL_ERROR;
 
  MoxPushN(clsNsPtr);
    ret = CtorNNN_direct(myNsO,argc,argv);
  MoxPopN();
 
  return ret;
}

libmyoox_CtorNNN_direct()

static int libmyoox_CtorNNN_direct ( MOX_RT_T moxrt, MOX_ENV_T interp, MOX_OBJ_T myNsO, int argc, const MOX_OBJ_T * argv )

static

Definition at line 335 of file libmyoox_mox.c.

  {
  MOX_OBJ_T ctorO = MoxNsGetVar(cls,__CTOR__);
    if (ctorO == NULL)  return TCL_ERROR;
  MOX_STRN ctorC  = VAL2STR(ctorO);
 
  // if {$cls(__CTOR__) ne ""} {
  if (ctorC[0] != '\0') {
    // $cls(__CTOR__) $myRef {*}$argsL
    RL_init(16, ctor_eval, ) ; RL_O(0,ctorO) ; RL_O(1,myNsO) ; RL_args(2,argc,argv);
    int retR = RL_EvalEx(TCL_EVAL_GLOBAL);
 
    // on error {err opt} {
    if (retR == TCL_ERROR) {
      // _ErrorCatchCtorFailedN $myNs $err $opt
      MOX_OBJ_T errOptO = Tcl_GetReturnOptions(interp,retR);
      RL_init(4, ctor_catch,  RL_NewS(0,"_ErrorCatchCtorFailedN"); RL_NewS(1,"CtorN")); 
                                RL_O(2,myNsO); RL_O(3,errOptO); 
      RL_EvalEx(0);
      return TCL_ERROR;
    }
 
  // } elseif {[llength $argsL]} {
  } else if (argc) {
    // _ErrorRaiseCtorInvalidArgumentN $myNs $argsL
    RL_init(4, ctor_raise,    RL_NewS(0,"_ErrorRaiseCtorInvalidArgumentN"); RL_NewS(1,"CtorN")); 
                                RL_O(2,myNsO); RL_NewL(3,argc,argv); 
    RL_EvalEx(0);
    return TCL_ERROR;
  }
  // set myRef
  Tcl_SetObjResult(interp,myNsO);
  return TCL_OK;
}

libmyoox_DestroyN()

int libmyoox_DestroyN

(

MOX_CMD_ARGS

)

Definition at line 456 of file libmyoox_mox.c.

                                {
  MOX_SETUP_hdl_static;
 
  if (objc < (1+__skip) || objc > (1+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"myNs");
    return TCL_ERROR;
  }
 
  MOX_OBJ_T myNsO = objv[__skip++];
 
  return MoxDestroyN(myNsO);
}

libmyoox_DestroyN_direct()

int libmyoox_DestroyN_direct	(	MOX_RT_T	moxrt,
		MOX_ENV_T	interp,
		MOX_OBJ_T	myNsO )

Definition at line 404 of file libmyoox_mox.c.

                                                                            {
 
  MOX_NS_T myNsPtr = MoxResolveN(myNsO);
    if (myNsPtr == NULL) return TCL_ERROR;
 
  MoxNsEval(myNsPtr) {
    MOX_OBJ_T clsNsO = MoxNsGetVar(my,__CLASS__);
      if (clsNsO == NULL) break;
 
    MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
      if (clsNsPtr == NULL) break;
 
    MoxNsEval(clsNsPtr) {
 
      MOX_OBJ_T dtorO = MoxNsGetVar(cls,__DTOR__);
        if (dtorO == NULL) break;
      MOX_STRN dtorC  = VAL2STR(dtorO);
 
      // if {$cls(__DTOR__) ne ""} { ...
      if (dtorC[0] != '\0') {
        // $cls(__DTOR__) $myRef
        RL_init(2, destroy_eval, ) ; RL_O(0,dtorO) ; RL_O(1,myNsO) ;
        int retR = RL_EvalEx(TCL_EVAL_GLOBAL);
 
        // on error {err opt} { ...
        if (retR == TCL_ERROR) {
          // _ErrorCatchDtorFailedN $myNs $err $opt
          MOX_OBJ_T errOptO = Tcl_GetReturnOptions(interp,retR);
          RL_init(4, destroy_catch, RL_NewS(0,"_ErrorCatchDtorFailedN"); RL_NewS(1,"DestroyN") ); 
            RL_O(2,myNsO); RL_O(3,errOptO); 
          RL_EvalEx(0);
          break;
        }
      }
    }
    MoxNsErrorCatch(clsNsPtr) {
      break;
    }
  }
 
  MoxNsErrorCatch(myNsPtr) {
    return TCL_ERROR;
  }
 
  // namespace delete $my(__NS__)
  Tcl_DeleteNamespace(myNsPtr);
 
  Tcl_FreeResult(interp);
  return TCL_OK;
}

libmyoox_MakeN()

int libmyoox_MakeN

(

MOX_CMD_ARGS

)

Definition at line 315 of file libmyoox_mox.c.

                             {
  MOX_SETUP_hdl_static;
  if (objc < (1+__skip) || objc > (3+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ?instName? ?instNs?");
    return TCL_ERROR;
  }
  MOX_OBJ_T clsNsO  = objv[__skip++];
  MOX_OBJ_T XnameO  = __skip < objc ? objv[__skip++] : NULL;
  MOX_OBJ_T XnsO    = __skip < objc ? objv[__skip++] : NULL;
 
  MOX_OBJ_T retO = MoxMakeNNN(clsNsO, XnameO, XnsO);
    if (retO == NULL) return TCL_ERROR;
 
  return TCL_OK;
}

libmyoox_MakeN_direct()

MOX_OBJ_T libmyoox_MakeN_direct	(	MOX_RT_T	moxrt,
		MOX_ENV_T	interp,
		MOX_OBJ_T	clsNsO,
		MOX_OBJ_T	Xname,
		MOX_OBJ_T	Xns )

used in public code

Definition at line 288 of file libmyoox_mox.c.

  {
  assert(moxrt  != NULL);
  assert(interp != NULL);
  assert(clsNsO != NULL);
 
  MOX_OBJ_T myNsO=NULL;
 
  MOX_NS_T clsNsPtr = MoxResolveN(clsNsO);
    if (clsNsPtr == NULL) return NULL;
 
  MoxPushN(clsNsPtr);
 
    // MoxMakeN $clsNs
    myNsO = MoxMakeNNN(clsNsO, Xname, Xns);
 
  MoxPopN();
 
  return myNsO;
}

libmyoox_MakeNNN_direct()

MOX_OBJ_T libmyoox_MakeNNN_direct	(	MOX_RT_T	moxrt,
		MOX_ENV_T	interp,
		MOX_OBJ_T	clsNsO,
		MOX_OBJ_T	XnameO,
		MOX_OBJ_T	XnsO )

Definition at line 170 of file libmyoox_mox.c.

  {
  Tcl_ResetResult(interp);
  #if !MOX_USE_OBJ_PRINTF
    char buf[256];
    int lenI;
  #endif
 
  assert(clsNsO != NULL);
  char* XnameC  = XnameO != NULL ? VAL2STR(XnameO) : NULL;
  char* XnsC    = XnsO   != NULL ? VAL2STR(XnsO)   : NULL;
  MOX_OBJ_T myNsO = NULL;
  MOX_OBJ_T myNameO = NULL;
  
  //if {$Xname eq ""} { ...
  if (XnameC == NULL) {
    // set Xname "$cls(__NAME__)-[incr cls(__INDEX__)]"
    MOX_OBJ_T XnameO = MoxClsNewInstName();
      if (XnameO == NULL) return NULL;
    myNameO = XnameO;
      Tcl_IncrRefCount(myNameO);
 
    // if {$Xns eq ""} { ...
    if (XnsC == NULL) {
      // set myNs "${clsNs}::$Xname"
      #if MOX_USE_OBJ_PRINTF
        myNsO = Tcl_ObjPrintf("%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO)); 
      #else
        lenI = snprintf(buf,256,"%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO));
        myNsO = Tcl_NewStringObj(buf,lenI);
      #endif
    } else {
      // set myNs "${Xns}::$Xname"
      #if MOX_USE_OBJ_PRINTF
        myNsO = Tcl_ObjPrintf("%s::%s", XnsC, VAL2STR(XnameO)); 
      #else
        lenI = snprintf(buf,256,"%s::%s", XnsC, VAL2STR(XnameO));
        myNsO = Tcl_NewStringObj(buf,lenI);
      #endif
    }
      Tcl_IncrRefCount(myNsO);
 
  // } elseif {[string match ::* $Xname]} { ...
  } else if (XnameC[0] == ':' && XnameC[1] == ':') {
    // set myNs "$Xname"
    myNsO = XnameO;
      Tcl_IncrRefCount(myNsO);
    myNameO = NamespaceTail(myNsO);
      Tcl_IncrRefCount(myNameO);
 
  // } elseif {$Xns eq ""} { ...
  } else if (XnsC == NULL) {
    // set myNs "${clsNs}::$Xname"
    #if MOX_USE_OBJ_PRINTF
      myNsO = Tcl_ObjPrintf("%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO)); 
    #else
      lenI = snprintf(buf,256,"%s::%s", VAL2STR(clsNsO), VAL2STR(XnameO));
      myNsO = Tcl_NewStringObj(buf,lenI);
    #endif
      Tcl_IncrRefCount(myNsO);
    myNameO = XnameO;
      Tcl_IncrRefCount(myNameO);
 
  // } else { ...
  } else {
    // set myNs "${Xns}::$Xname"
    #if MOX_USE_OBJ_PRINTF
      myNsO = Tcl_ObjPrintf("%s::%s", XnsC, VAL2STR(XnameO)); 
    #else
      lenI = snprintf(buf,256,"%s::%s", XnsC, VAL2STR(XnameO));
      myNsO = Tcl_NewStringObj(buf,lenI);
    #endif
      Tcl_IncrRefCount(myNsO);
    myNameO = XnameO;
      Tcl_IncrRefCount(myNameO);
  }
 
  MOX_STRN myNsC = VAL2STR(myNsO);
 
  MOX_NS_T myNsPtr = Tcl_FindNamespace(interp,myNsC,NULL,TCL_GLOBAL_ONLY);
 
  // if {![namespace exists $myNs]} { ...
  if (myNsPtr == NULL) {
 
    myNsPtr = Tcl_CreateNamespace(interp,myNsC,NULL /*ClientData*/, NULL /*ClientProc*/);
      if (myNsPtr == NULL) goto error;
 
    MoxNsEval(myNsPtr) {
    
      #define MoxSetVar(tok,val) \
        if ( MoxNsSetVar(my,tok,val) == NULL ) break
        MoxSetVar(__NS__,         myNsO);           // __NS__          $myNs
        MoxSetVar(__NAME__,       myNameO);         // __NAME__        [namespace tail $myNs]
        MoxSetVar(__CLASS__,      clsNsO);          // __CLASS__       $clsNs
      #undef MoxSetVar
 
    }
 
    MoxNsErrorCatch(myNsPtr) {
      goto error;
    }
  }
 
  // set myNs
  Tcl_SetObjResult(interp,myNsO);
 
error:
  if (myNsO)    Tcl_DecrRefCount(myNsO);
  if (myNameO)  Tcl_DecrRefCount(myNameO);
  return myNsO;
}

libmyoox_NamespaceTailObjCmd()

mox_inline MOX_OBJ_T libmyoox_NamespaceTailObjCmd

(

MOX_OBJ_T

nameO

)

Definition at line 18 of file libmyoox_mox.c.

                                                              {
  MOX_STRN name = VAL2STR(nameO);
  // from: NamespaceTailCmd --------------------------
  MOX_STRN p;
  for (p = name;  *p != '\0';  p++) {
      /* empty body */
  }
  while (--p > name) {
      if ((*p == ':') && (*(p-1) == ':')) {
          p++;                        /* Just after the last "::" */
          break;
      }
  }
 
  if (p >= name) {
      name = p;
  }
  // ------------------------------------------------
  return STR2VAL(name);
}

libmyoox_NewN()

int libmyoox_NewN

(

MOX_CMD_ARGS

)

Definition at line 548 of file libmyoox_mox.c.

                            {
  MOX_SETUP_hdl_static;
 
  if (objc < (1+__skip)) {
    Tcl_WrongNumArgs(interp,__skip,objv,"clsNs ...");
    return TCL_ERROR;
  }
  MOX_OBJ_T clsNsO = objv[__skip++];
 
  return MoxCreate3N(clsNsO,NULL,NULL,objc-2,objv+2);
}