Here's my code which shows how to (in short) do a deep copy of a Tcl_Obj structure from C.
It stores any unknown type as string and the following in internal represenatation:
*list (including sublists) *int/long/double
Here's the main code:
*deepcopy.c
#include <tcl.h>
#include <deepcopy.h>
#include <deepcopyInt.h>
/* external API */
void *Dc_GetTclObj(Tcl_Obj *obj) /* {{{ */
{
void *rc;
char *otype="";
if (obj->typePtr!=NULL)
{
otype=obj->typePtr->name;
}
if (!strcmp(otype,"int"))
rc=int_GetTclObj(obj);
else if (!strcmp(otype,"long"))
rc=long_GetTclObj(obj);
else if (!strcmp(otype,"double"))
rc=double_GetTclObj(obj);
else if (!strcmp(otype,"list"))
rc=list_GetTclObj(obj);
else
rc=str_GetTclObj(obj);
return(rc);
}
/* }}} */
Tcl_Obj *Dc_NewTclObj(void *ptr) /* {{{ */
{
struct dcObjHead *oh=ptr;
Tcl_Obj *rc=NULL;
switch (oh->type)
{
case DCO_STRING:
rc=str_NewTclObj(ptr);
break;
case DCO_LIST:
rc=list_NewTclObj(ptr);
break;
case DCO_INTEGER:
rc=int_NewTclObj(ptr);
break;
case DCO_DOUBLE:
rc=double_NewTclObj(ptr);
break;
case DCO_LONG:
rc=long_NewTclObj(ptr);
break;
}
return(rc);
}
/* }}} */
void Dc_FreeDcObj(void *ptr) /* {{{ */
{
struct dcObjHead *oh=ptr;
switch (oh->type)
{
case DCO_STRING:
str_Free(ptr);
break;
case DCO_LIST:
list_Free(ptr);
break;
case DCO_INTEGER:
int_Free(ptr);
break;
case DCO_LONG:
long_Free(ptr);
break;
case DCO_DOUBLE:
double_Free(ptr);
break;
}
}
/* }}} */
unsigned long Dc_ObjSize(void *ptr) /* {{{ */
{
struct dcObjHead *oh=ptr;
return(oh->size);
}
/* }}} */
/* internal type representations */
static struct dcObjHead *str_GetTclObj(Tcl_Obj *to) /* {{{ */
{
struct dcStrObj *rc;
unsigned long size;
int strlen;
char *str;
str=Tcl_GetStringFromObj(to,&strlen);
size=strlen+1+sizeof(struct dcObjHead);
if (rc=(struct dcStrObj *) dc_Malloc(size))
{
memcpy(rc->string,str,strlen);
rc->string[strlen]='\0';
rc->head.type=DCO_STRING;
rc->head.size=size;
}
return ((struct dcObjHead *) rc);
}
/* }}} */
Tcl_Obj *str_NewTclObj(struct dcObjHead *o) /* {{{ */
{
struct dcStrObj *so=(struct dcStrObj *) o;
Tcl_Obj *rc=NULL;
if (o->type==DCO_STRING)
{
rc=Tcl_NewStringObj(so->string,o->size-sizeof(struct dcObjHead)-1);
}
return(rc);
}
/* }}} */
static void str_Free(struct dcObjHead *o) /* {{{ */
{
if (o->type==DCO_STRING)
{
dc_Free(o);
}
}
/* }}} */
static struct dcObjHead *int_GetTclObj(Tcl_Obj *to) /* {{{ */
{
struct dcIntObj *rc;
if (rc=(struct dcIntObj *) dc_Malloc(sizeof(struct dcIntObj)))
{
Tcl_GetIntFromObj(NULL,to,&rc->value);
rc->head.type=DCO_INTEGER;
rc->head.size=sizeof(struct dcIntObj);
}
return ((struct dcObjHead *) rc);
}
/* }}} */
Tcl_Obj *int_NewTclObj(struct dcObjHead *o) /* {{{ */
{
struct dcIntObj *so=(struct dcIntObj *) o;
Tcl_Obj *rc=NULL;
if (o->type==DCO_INTEGER)
{
rc=Tcl_NewIntObj(so->value);
}
return(rc);
}
/* }}} */
static void int_Free(struct dcObjHead *o) /* {{{ */
{
if (o->type==DCO_INTEGER)
{
dc_Free((void *) o);
}
}
/* }}} */
static struct dcObjHead *long_GetTclObj(Tcl_Obj *to) /* {{{ */
{
struct dcLongObj *rc;
if (rc=(struct dcLongObj *) dc_Malloc(sizeof(struct dcLongObj)))
{
Tcl_GetLongFromObj(NULL,to,&rc->value);
rc->head.type=DCO_LONG;
rc->head.size=sizeof(struct dcLongObj);
}
return ((struct dcObjHead *) rc);
}
/* }}} */
Tcl_Obj *long_NewTclObj(struct dcObjHead *o) /* {{{ */
{
struct dcLongObj *so=(struct dcLongObj *) o;
Tcl_Obj *rc=NULL;
if (o->type==DCO_LONG)
{
rc=Tcl_NewLongObj(so->value);
}
return(rc);
}
/* }}} */
static void long_Free(struct dcObjHead *o) /* {{{ */
{
if (o->type==DCO_LONG)
{
dc_Free((void *) o);
}
}
/* }}} */
static struct dcObjHead *double_GetTclObj(Tcl_Obj *to) /* {{{ */
{
struct dcDoubleObj *rc;
if (rc=(struct dcDoubleObj *) dc_Malloc(sizeof(struct dcDoubleObj)))
{
Tcl_GetDoubleFromObj(NULL,to,&rc->value);
rc->head.type=DCO_DOUBLE;
rc->head.size=sizeof(struct dcDoubleObj);
}
return ((struct dcObjHead *) rc);
}
/* }}} */
Tcl_Obj *double_NewTclObj(struct dcObjHead *o) /* {{{ */
{
struct dcDoubleObj *so=(struct dcDoubleObj *) o;
Tcl_Obj *rc=NULL;
if (o->type==DCO_DOUBLE)
{
rc=Tcl_NewDoubleObj(so->value);
}
return(rc);
}
/* }}} */
static void double_Free(struct dcObjHead *o) /* {{{ */
{
if (o->type==DCO_DOUBLE)
{
dc_Free((void *) o);
}
}
/* }}} */
static struct dcObjHead *list_GetTclObj(Tcl_Obj *to) /* {{{ */
{
Tcl_Obj *elem;
struct dcListObj *rc;
int size,llen,i;
if (Tcl_ListObjLength(NULL,to,&llen)!=TCL_OK)
return(NULL);
size=sizeof(struct dcListObj)+(llen-1)*sizeof(struct dcListObj *);
if (rc=(struct dcListObj *) dc_Malloc(size))
{
rc->head.type=DCO_LIST;
rc->nelem=llen;
for (i=0;i<llen;i++)
{
if (Tcl_ListObjIndex(NULL,to,i,&elem)!=TCL_OK)
rc->list[i]=NULL;
else
{
rc->list[i]=Dc_GetTclObj(elem);
size+=rc->list[i]->size;
}
}
rc->head.size=size;
}
return ((struct dcObjHead *) rc);
}
/* }}} */
Tcl_Obj *list_NewTclObj(struct dcObjHead *o) /* {{{ */
{
struct dcListObj *so=(struct dcListObj *) o;
Tcl_Obj *rc=NULL,**tbl;
int llen,i;
if (o->type==DCO_LIST)
{
llen=so->nelem;
if ((tbl=dc_Malloc(llen*sizeof(Tcl_Obj *)))!=NULL)
{
for (i=0;i<llen;i++)
{
tbl[i]=Dc_NewTclObj(so->list[i]);
}
rc=Tcl_NewListObj(llen,tbl);
dc_Free(tbl);
}
}
return(rc);
}
/* }}} */
static void list_Free(struct dcObjHead *o) /* {{{ */
{
struct dcListObj *so=o;
int i;
if (o->type==DCO_LIST)
{
for (i=0;i<so->nelem;i++)
{
Dc_FreeDcObj(so->list[i]);
}
dc_Free((void *) o);
}
}
/* }}} */