Object.Clone Method

BlitzMax Forums/BlitzMax Module Tweaks/Object.Clone Method

N	(Posted 2006) [#1]

There are some undesirable consequences of using this. My advice? Don't use it unless you feel like going through it and finding out what's wrong.

Added...

blitz_object.c

#include "blitz.h"

static BBDebugScope debugScope={
	BBDEBUGSCOPE_USERTYPE,
	"Object",
	BBDEBUGDECL_END
};

BBClass bbObjectClass={
	0,				//super
	bbObjectFree,   //free
	&debugScope,	//debug_scope
	8,				//instance_size
	
	bbObjectCtor,
	bbObjectDtor,
	bbObjectToString,
	bbObjectCompare,
	bbObjectSendMessage,
	bbObjectReserved,
	bbObjectReserved,
	bbObjectReserved,
	bbObjectClone, // Clone method added after reserved methods
};

BBObject bbNullObject={
	0,				//clas
	BBGC_MANYREFS	//refs
};

BBObject *bbObjectNew( BBClass *t ){
	BBObject *o=(BBObject*)bbGCAlloc( t->instance_size,(BBGCPool*)t );
	t->ctor( o );
	return o;
}

void bbObjectFree( BBObject *o ){
	BBClass *clas;

	if( o==&bbNullObject ){
		o->refs=BBGC_MANYREFS;
		return;
	}
	
	clas=o->clas;
	clas->dtor( o );
	bbGCMemFree( o,clas->instance_size );
}

void bbObjectCtor( BBObject *o ){
	o->clas=&bbObjectClass;
}

void bbObjectDtor( BBObject *o ){
	o->clas=0;
}

BBString *bbObjectToString( BBObject *o ){
	char buf[32];
	sprintf( buf,"%p",o );
	return bbStringFromCString( buf );
}

int bbObjectCompare( BBObject *x,BBObject *y ){
	return (char*)x-(char*)y;
}

BBObject *bbObjectSendMessage( BBObject *m,BBObject *s ){
	return &bbNullObject;
}

void bbObjectReserved(){
	bbExThrowCString( "Illegal call to reserved method" );
}

BBObject *bbObjectClone( BBObject *o ){
    return &bbNullObject;   // unless implemented, return Null
}

BBObject *bbObjectDowncast( BBObject *o,BBClass *t ){
	BBClass *p=o->clas;
	while( p && p!=t ) p=p->super;
	return p ? o : &bbNullObject;
}

void bbObjectRetain( BBObject *o ){
	BBRETAIN( o );
}

void bbObjectRelease( BBObject *o ){
	BBRELEASE( o );
}

blitz_object.h

#ifndef BLITZ_OBJECT_H
#define BLITZ_OBJECT_H

#include "blitz_types.h"

#ifdef __cplusplus
extern "C"{
#endif

#define BBNULL (&bbNullObject)

struct BBClass{
	//extends BBGCPool
	BBClass*	super;
	void		(*free)( BBObject *o );
	
	BBDebugScope*debug_scope;

	int			instance_size;

	void		(*ctor)( BBObject *o );
	void		(*dtor)( BBObject *o );
	
	BBString*	(*ToString)( BBObject *x );
	int			(*Compare)( BBObject *x,BBObject *y );
	BBObject*	(*SendMessage)( BBObject *m,BBObject *s );
	void		(*_reserved1_)();
	void		(*_reserved2_)();
	void		(*_reserved3_)();
	
	void*		vfns[24];  // Increased the function count to 24
};

struct BBObject{
	//extends BBGCMem
	BBClass*	clas;
	int			refs;
};

extern		BBClass	bbObjectClass;
extern		BBObject bbNullObject;

BBObject*	bbObjectNew( BBClass *t );
void		bbObjectFree( BBObject *o );

BBObject*   bbObjectClone( BBObject *o ); // Forward declaration of Object.Clone method

void		bbObjectCtor( BBObject *o );
void		bbObjectDtor( BBObject *o );

BBString*	bbObjectToString( BBObject *o );
int			bbObjectCompare( BBObject *x,BBObject *y );
BBObject*	bbObjectSendMessage( BBObject *m,BBObject *s );
void		bbObjectReserved();

BBObject*	bbObjectDowncast( BBObject *o,BBClass *t );

void		bbObjectRetain( BBObject *o );
void		bbObjectRelease( BBObject *o );

#ifdef __cplusplus
}
#endif

#endif

blitz_string.c

#include "blitz.h"

static void bbStringFree( BBObject *o );

static BBDebugScope debugScope={
	BBDEBUGSCOPE_USERTYPE,
	"String",
	BBDEBUGDECL_END
};

BBClass bbStringClass={
	&bbObjectClass, //super
	bbStringFree,   //free
	&debugScope,	//DebugScope
	0,				//instance_size
	0,				//ctor
	0,				//dtor

	(BBString*(*)(BBObject*))bbStringToString,
	(int(*)(BBObject*,BBObject*))bbStringCompare,
	bbObjectSendMessage,
	bbObjectReserved,
	bbObjectReserved,
	bbObjectReserved,
	
    bbStringClone,  // Added String.Clone method after reserved methods
	
	bbStringFind,
	bbStringFindLast,
	bbStringTrim,
	bbStringReplace,
	
	bbStringToLower,
	bbStringToUpper,
	
	bbStringToInt,
	bbStringToLong,
	bbStringToFloat,
	bbStringToDouble,
	bbStringToCString,
	bbStringToWString,

	bbStringFromInt,
	bbStringFromLong,
	bbStringFromFloat,
	bbStringFromDouble,
	bbStringFromCString,
	bbStringFromWString,
	
	bbStringFromBytes,
	bbStringFromShorts
};

BBString bbEmptyString={
	&bbStringClass, //clas
	BBGC_MANYREFS,	//refs
	0				//length
};

static int wstrlen( const BBChar *p ){
	const BBChar *t=p;
	while( *t ) ++t;
	return t-p;
}

static void bbStringFree( BBObject *o ){
	BBString *str=(BBString*)o;

	if( str==&bbEmptyString ){
		str->refs=BBGC_MANYREFS;
		return;
	}

	bbGCMemFree( str,sizeof(BBString)+str->length*sizeof(BBChar) );
}

BBString *bbStringNew( int len ){
	BBString *str;
	if( !len ) return &bbEmptyString;
	str=(BBString*)bbGCAlloc( sizeof(BBString)+len*sizeof(BBChar),(BBGCPool*)&bbStringClass );
	str->length=len;
	return str;
}

BBString *bbStringFromChar( int c ){
	BBString *str=bbStringNew(1);
	str->buf[0]=c;
	return str;
}

BBString *bbStringFromInt( int n ){
	char buf[64],*p=buf+64;
	int neg=n<0;
	if( neg ){
		n=-n;if( n<0 ) return bbStringFromBytes( "-2147483648",11 );
	}
	do{
		*--p=n%10+'0';
	}while(n/=10);
	if( neg ) *--p='-';
	return bbStringFromBytes( p,buf+64-p );
}

BBString *bbStringFromLong( BBInt64 n ){
	char buf[64],*p=buf+64;
	int neg=n<0;
	if( neg ){
		n=-n;if( n<0 ) return bbStringFromBytes( "-9223372036854775808",20 );
	}
	do{
		*--p=n%10+'0';
	}while(n/=10);
	if( neg ) *--p='-';
	return bbStringFromBytes( p,buf+64-p );
}

BBString *bbStringFromFloat( float n ){
	char buf[64];
	sprintf( buf,"%#.9g",n );
	return bbStringFromCString(buf);
}

BBString *bbStringFromDouble( double n ){
	char buf[64];
	sprintf( buf,"%#.17lg",n );
	return bbStringFromCString(buf);
}

BBString *bbStringFromBytes( const char *p,int n ){
	int k;
	BBString *str;
	if( !n ) return &bbEmptyString;
	str=bbStringNew( n );
	for( k=0;k<n;++k ) str->buf[k]=(unsigned char)p[k];
	return str;
}

BBString *bbStringFromShorts( const unsigned short *p,int n ){
	BBString *str;
	if( !n ) return &bbEmptyString;
	str=bbStringNew( n );
	bbMemCopy( str->buf,p,n*sizeof(short) );
	return str;
}

BBString *bbStringFromInts( const int *p,int n ){
	int k;
	BBString *str;
	if( !n ) return &bbEmptyString;
	str=bbStringNew( n );
	for( k=0;k<n;++k ) str->buf[k]=p[k];
	return str;
}

BBString *bbStringFromArray( BBArray *arr ){
	int n;
	void *p;
	if( arr->dims!=1 ) return &bbEmptyString;
	n=arr->scales[0];
	p=BBARRAYDATA(arr,arr->dims);
	switch( arr->type[0] ){
	case 'b':return bbStringFromBytes( p,n );
	case 's':return bbStringFromShorts( p,n );
	case 'i':return bbStringFromInts( p,n );
	}
	return &bbEmptyString;
}

BBString *bbStringFromCString( const char *p ){
	return p ? bbStringFromBytes( p,strlen(p) ) : &bbEmptyString;
}

BBString *bbStringFromWString( const BBChar *p ){
	return p ? bbStringFromShorts( p,wstrlen(p) ) : &bbEmptyString;
}

BBString *bbStringToString( BBString *t ){
	return t;
}

int bbStringCompare( BBString *x,BBString *y ){
	int k,n,sz;
	sz=x->length<y->length ? x->length : y->length;
	for( k=0;k<sz;++k ) if( n=x->buf[k]-y->buf[k] ) return n;
	return x->length-y->length;
}

BBString *bbStringConcat( BBString *x,BBString *y ){
    int len=x->length+y->length;
    BBString *t=bbStringNew(len);
    memcpy( t->buf,x->buf,x->length*sizeof(BBChar) );
    memcpy( t->buf+x->length,y->buf,y->length*sizeof(BBChar) );
    return t;
}

BBString *bbStringSlice( BBString *in,int beg,int end ){
	BBChar *p;
	BBString *out;
	int k,n,len,inlen;
	
	len=end-beg;
	if( len<=0 ) return &bbEmptyString;

	out=bbStringNew( len );
	
	p=out->buf;
	inlen=in->length;

	if( (n=-beg)>0 ){
		if( beg+n>end ) n=end-beg;
		for( k=0;k<n;++k ) *p++=' ';
		if( (beg+=n)==end ) return out;
	}
	if( (n=inlen-beg)>0 ){
		BBChar *q=in->buf+beg;
		if( beg+n>end ) n=end-beg;
		for( k=0;k<n;++k ) *p++=*q++;
		if( (beg+=n)==end ) return out;
	}
	if( (n=end-beg)>0 ){
		for( k=0;k<n;++k ) *p++=' ';
	}
	return out;
}

BBString *bbStringTrim( BBString *str ){
	int b=0,e=str->length;
	while( b<e && str->buf[b]<=' ' ) ++b;
	if( b==e ) return &bbEmptyString;
	while( str->buf[e-1]<=' ' ) --e;
	if( e-b==str->length ) return str;
	return bbStringFromShorts( str->buf+b,e-b );
}

BBString *bbStringReplace( BBString *str,BBString *sub,BBString *rep ){
	int i,d,n,j,p;
	if( !sub->length ) return str;
	i=0;n=0;
	while( (i=bbStringFind(str,sub,i))!=-1 ) {i+=sub->length;n++;}
	if (!n) return str;
	d=rep->length-sub->length;
	BBString *t=bbStringNew( str->length+d*n );
	i=0;p=0;
	while( (j=bbStringFind(str,sub,i))!=-1 )
	{
		n=j-i;if (n) {memcpy( t->buf+p,str->buf+i,n*sizeof(BBChar) );p+=n;}
		n=rep->length;memcpy( t->buf+p,rep->buf,n*sizeof(BBChar) );p+=n;
		i=j+sub->length;		
	}
	n=str->length-i;
	if (n) memcpy( t->buf+p,str->buf+i,n*sizeof(BBChar) );
	return t;
}

int bbStringAsc( BBString *t ){
	return t->length ? t->buf[0] : -1;
}

static int charsEqual( unsigned short *a,unsigned short *b,int n ){
	//not sure...alignment issues?
	//for( ;n>=2;n-=2 ){
	//	if( *(int*)a!=*(int*)b ) return 0;
	//	a+=2;b+=2;
	//}
	while( n-- ){
		if (*a!=*b) return 0;
		a++;b++;
	}
	return 1;
}

int bbStringFind( BBString *x,BBString *y,int i ){
	bbassert( i>=0 );
	while( i+y->length<=x->length ){
		if( charsEqual( x->buf+i,y->buf,y->length ) ) return i;
		++i;
	}
	return -1;
}

int bbStringFindLast( BBString *x,BBString *y,int i ){
	bbassert( i>=0 );
	i=x->length-i;
	if (i+y->length>x->length) i=x->length-y->length;
	while (i>=0)
	{
		if( charsEqual( x->buf+i,y->buf,y->length ) ) return i;
		--i;
	}
	return -1;
}

/*
int bbStringFindLast( BBString *x,BBString *y,int i ){
	int p;
	bbassert( i>=0 );
	p=x->length-y->length;
	while( p>=i ){
		if( charsEqual( x->buf+p,y->buf,y->length ) ) return p;
		--p;
	}
	return -1;
}
*/
int bbStringToInt( BBString *t ){
	int i=0,neg=0,n=0;
	
	while( i<t->length && isspace(t->buf[i]) ) ++i;
	if( i==t->length ) return 0;
	
	if( t->buf[i]=='+' ) ++i;
	else if( neg=(t->buf[i]=='-') ) ++i;
	if( i==t->length ) return 0;

	if( t->buf[i]=='%' ){
		for( ++i;i<t->length;++i ){
			int c=t->buf[i];
			if( c!='0' && c!='1' ) break;
			n=n*2+(c-'0');
		}
	}else if( t->buf[i]=='$' ){
		for( ++i;i<t->length;++i ){
			int c=toupper(t->buf[i]);
			if( !isxdigit(c) ) break;
			if( c>='A' ) c-=('A'-'0'-10);
			n=n*16+(c-'0');
		}
	}else{
		for( ;i<t->length;++i ){
			int c=t->buf[i];
			if( !isdigit(c) ) break;
			n=n*10+(c-'0');
		}
	}
	return neg ? -n : n;
}

void bbStringToLong( BBString *t,BBInt64 *r ){
	int i=0,neg=0;
	BBInt64 n=0;
	
	while( i<t->length && isspace(t->buf[i]) ) ++i;
	if( i==t->length ){ *r=0;return; }
	
	if( t->buf[i]=='+' ) ++i;
	else if( neg=(t->buf[i]=='-') ) ++i;
	if( i==t->length ){ *r=0;return; }
	
	if( t->buf[i]=='%' ){
		for( ++i;i<t->length;++i ){
			int c=t->buf[i];
			if( c!='0' && c!='1' ) break;
			n=n*2+(c-'0');
		}
	}else if( t->buf[i]=='$' ){
		for( ++i;i<t->length;++i ){
			int c=toupper(t->buf[i]);
			if( !isxdigit(c) ) break;
			if( c>='A' ) c-=('A'-'0'-10);
			n=n*16+(c-'0');
		}
	}else{
		for( ;i<t->length;++i ){
			int c=t->buf[i];
			if( !isdigit(c) ) break;
			n=n*10+(c-'0');
		}
	}
	*r=neg ? -n : n;
}

float bbStringToFloat( BBString *t ){
	char *p=bbStringToCString( t );
	float n=atof( p );
	bbMemFree( p );
	return n;
}

double bbStringToDouble( BBString *t ){
	char *p=bbStringToCString( t );
	double n=atof( p );
	bbMemFree( p );
	return n;
}

BBString *bbStringToLower( BBString *str ){
	int k;
	BBString *t;
	t=bbStringNew( str->length );
	for( k=0;k<str->length;++k ){
		int c=str->buf[k];
		t->buf[k]=(c>='A' && c<='Z') ? (c|32) : c;
	}
	return t;
}

BBString *bbStringToUpper( BBString *str ){
	int k;
	BBString *t;
	t=bbStringNew( str->length );
	for( k=0;k<str->length;++k ){
		int c=str->buf[k];
		t->buf[k]=(c>='a' && c<='z') ? (c&~32) : c;
	}
	return t;
}

char *bbStringToCString( BBString *str ){
	char *p;
	int k,sz=str->length;
	p=(char*)bbMemAlloc( sz+1 );
	for( k=0;k<sz;++k ) p[k]=str->buf[k];
	p[sz]=0;
	return p;
}

BBChar *bbStringToWString( BBString *str ){
	BBChar *p;
	int k,sz=str->length;
	p=(BBChar*)bbMemAlloc( (sz+1)*sizeof(BBChar) );
	memcpy(p,str->buf,sz*sizeof(BBChar));
	p[sz]=0;
	return p;
}

// String.Clone method
BBString *bbStringClone( BBString *str ){
    BBString *t;
    t = bbStringNew( str->length );
    memcpy( t->buf, str->buf, str->length*sizeof(BBChar) );
    return t;
}

blitz_string.h

#ifndef BLITZ_STRING_H
#define BLITZ_STRING_H

#include "blitz_types.h"

#ifdef __cplusplus
extern "C"{
#endif

struct BBString{
	BBClass*	clas;
	int			refs;
	int			length;
	BBChar		buf[];
};

extern	BBClass bbStringClass;
extern	BBString bbEmptyString;

BBString*bbStringNew( int len );
BBString*bbStringFromChar( int c );

BBString*bbStringFromInt( int n );
BBString*	bbStringFromLong( BBInt64 n );
BBString*bbStringFromFloat( float n );
BBString*	bbStringFromDouble( double n );
BBString*	bbStringFromBytes( const char *p,int n );
BBString*	bbStringFromShorts( const unsigned short *p,int n );
BBString*	bbStringFromInts( const int *p,int n );
BBString*bbStringFromArray( BBArray *arr );
BBString*	bbStringFromCString( const char *p );
BBString*bbStringFromWString( const BBChar *p );

BBString*	bbStringToString( BBString *t );
int		bbStringCompare( BBString *x,BBString *y );

BBString*bbStringConcat( BBString *x,BBString *y );

BBString*	bbStringTrim( BBString *t );
BBString*	bbStringSlice( BBString *t,int beg,int end );
BBString*	bbStringReplace( BBString *str,BBString *sub,BBString *rep );

int		bbStringAsc( BBString *t );
int		bbStringFind( BBString *x,BBString *y,int i );
int		bbStringFindLast( BBString *x,BBString *y,int i );
BBString*	bbStringToLower( BBString *str );
BBString*	bbStringToUpper( BBString *str );

int		bbStringToInt( BBString *str );
float	bbStringToFloat( BBString *str );
double	bbStringToDouble( BBString *str );
void		bbStringToLong( BBString *str,BBInt64 *r );
char*	bbStringToCString( BBString *str );
BBChar*	bbStringToWString( BBString *str );

BBString *bbStringClone( BBString *str );  // Forward declaration of String.Clone method

#ifdef __cplusplus
}
#endif

#endif

Edit: I neglected to mention you will have to modify the blitz_classes.i to look like this:


Object^Null{

	-New()="bbObjectCtor"
	-Delete()="bbObjectDtor"
    -Clone:Object()="bbObjectClone"
	-ToString:String()="bbObjectToString"
	-Compare:Int( otherObject:Object )="bbObjectCompare"
	-SendMessage:Object( message:Object,source:object )="bbObjectSendMessage"
	-_reserved1_()="bbObjectReserved"
	-_reserved2_()="bbObjectReserved"
	-_reserved3_()="bbObjectReserved"
	
}="bbObjectClass"

String^Object{

	.length:Int

    -Clone:Object()="bbStringClone"
    
	-ToString:String()="bbStringToString"
	-Compare:Int(otherObject:Object)="bbStringCompare"
	
	-Find:Int( subString:String,startIndex=0 )="bbStringFind"
	-FindLast:Int( subString:String,startIndex=0 )="bbStringFindLast"
	
	-Trim:String()="bbStringTrim"
	-Replace:String( substring:String,withString:String )="bbStringReplace"

	-ToLower:String()="bbStringToLower"
	-ToUpper:String()="bbStringToUpper"
	
	-ToInt:Int()="bbStringToInt"
	-ToLong:Long()="bbStringToLong"
	-ToFloat:Float()="bbStringToFloat"
	-ToDouble:Double()="bbStringToDouble"
	-ToCString:Byte Ptr()="bbStringToCString"
	-ToWString:Short Ptr()="bbStringToWString"
	
	+FromInt:String( intValue:Int)="bbStringFromInt"
	+FromLong:String( longValue:Long )="bbStringFromLong"
	+FromFloat:String( floatValue:Float )="bbStringFromFloat"
	+FromDouble:String( doubleValue:Double )="bbStringFromDouble"
	+FromCString:String( cString:Byte Ptr )="bbStringFromCString"
	+FromWString:String( wString:short ptr )="bbStringFromWString"
	
	+FromBytes:String( bytes:Byte Ptr,count )="bbStringFromBytes"
	+FromShorts:String( shorts:Short Ptr,count )="bbStringFromShorts"

}AF="bbStringClass"

Array^Object{

	.elementTypeEncoding:Byte Ptr
	.numberOfDimensions:Int
	.sizeMinusHeader:Int
	.length:Int
	
	-Sort( ascending=1 )="bbArraySort"
	-Dimensions:Int[]()="bbArrayDimensions"
	
}AF="bbArrayClass"

Note the addition of the Clone methods to the String and Object classes. It is not added to the Array class because it is already implemented in its base class (which is, obviously, Object).

Have fun.

Hotcakes

(Posted 2006) [#2]

Adding this to the BRL mods officially will result in BRL employees having one less topic to ignore whenever I bump it. =]

Dreamora

(Posted 2006) [#3]

Great addition :-)
Thanks for sharing it Noel :)
(tried to do it myself but struggled because I didn't know that I had to manually modify the classes.i ... thought all of them were created automatically on build modules)

Dreamora

(Posted 2006) [#4]

Warning:
Do not add clone to your BM if you need to use TMap. It won't be able to return anything anymore if clone is added. Don't ask me for the reason ...

Jay Kyburz

(Posted 2006) [#5]

I agree, this would be awsome if it was made official.

N	(Posted 2006) [#6]

I wouldn't recommend adding it at all. At least not this way. There are some unusual consequences for doing so, and I promise you'll notice them.

Dreamora

(Posted 2006) [#7]

Would have been nice if you added that upfront that it is only to look good but not for usage, which is what module tweaks are for ... would have saved me 2 days where I tried to find out why TMap fails to find anything although Keys clearly showed the searched key ...

N	(Posted 2006) [#8]

I only found it out recently, so don't blame me.

Edit: Frankly, this is a tweak to the official modules. There is no guarantee of it working or that it won't mess something up. So, once again, don't blame me for your code not working when you decide to use a tweak that isn't part of the official code.